OSDN Git Service

2006-10-10 Brooks Moses <bmoses@stanford.edu>
[pf3gnuchains/gcc-fork.git] / gcc / fortran / gfortran.texi
1 \input texinfo  @c -*-texinfo-*-
2 @c %**start of header
3 @setfilename gfortran.info
4 @set copyrights-gfortran 1999-2006
5
6 @include gcc-common.texi
7
8 @settitle The GNU Fortran Compiler
9
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
18
19 @c %**end of header
20
21 @c Use with @@smallbook.
22
23 @c %** start of document
24
25 @c Cause even numbered pages to be printed on the left hand side of
26 @c the page and odd numbered pages to be printed on the right hand
27 @c side of the page.  Using this, you can print on both sides of a
28 @c sheet of paper and have the text on the same part of the sheet.
29
30 @c The text on right hand pages is pushed towards the right hand
31 @c margin and the text on left hand pages is pushed toward the left
32 @c hand margin.
33 @c (To provide the reverse effect, set bindingoffset to -0.75in.)
34
35 @c @tex
36 @c \global\bindingoffset=0.75in
37 @c \global\normaloffset =0.75in
38 @c @end tex
39
40 @copying
41 Copyright @copyright{} @value{copyrights-gfortran} Free Software Foundation, Inc.
42
43 Permission is granted to copy, distribute and/or modify this document
44 under the terms of the GNU Free Documentation License, Version 1.1 or
45 any later version published by the Free Software Foundation; with the
46 Invariant Sections being ``GNU General Public License'' and ``Funding
47 Free Software'', the Front-Cover
48 texts being (a) (see below), and with the Back-Cover Texts being (b)
49 (see below).  A copy of the license is included in the section entitled
50 ``GNU Free Documentation License''.
51
52 (a) The FSF's Front-Cover Text is:
53
54      A GNU Manual
55
56 (b) The FSF's Back-Cover Text is:
57
58      You have freedom to copy and modify this GNU Manual, like GNU
59      software.  Copies published by the Free Software Foundation raise
60      funds for GNU development.
61 @end copying
62
63 @ifinfo
64 @dircategory Software development
65 @direntry
66 * gfortran: (gfortran).                  The GNU Fortran Compiler.
67 @end direntry
68 This file documents the use and the internals of
69 the GNU Fortran compiler, (@command{gfortran}).
70
71 Published by the Free Software Foundation
72 51 Franklin Street, Fifth Floor
73 Boston, MA 02110-1301 USA
74
75 @insertcopying
76 @end ifinfo
77
78
79 @setchapternewpage odd
80 @titlepage
81 @title Using GNU Fortran
82 @sp 2
83 @center The gfortran team
84 @page
85 @vskip 0pt plus 1filll
86 For the @value{version-GCC} Version*
87 @sp 1
88 Published by the Free Software Foundation @*
89 51 Franklin Street, Fifth Floor@*
90 Boston, MA 02110-1301, USA@*
91 @c Last printed ??ber, 19??.@*
92 @c Printed copies are available for $? each.@*
93 @c ISBN ???
94 @sp 1
95 @insertcopying
96 @end titlepage
97 @summarycontents
98 @contents
99 @page
100
101 @node Top
102 @top Introduction
103 @cindex Introduction
104
105 This manual documents the use of @command{gfortran}, 
106 the GNU Fortran compiler. You can find in this manual how to invoke
107 @command{gfortran}, as well as its features and incompatibilities.
108
109 @ifset DEVELOPMENT
110 @emph{Warning:} This document, and the compiler it describes, are still
111 under development.  While efforts are made to keep it up-to-date, it might
112 not accurately reflect the status of the most recent GNU Fortran compiler.
113 @end ifset
114
115 @comment
116 @comment  When you add a new menu item, please keep the right hand
117 @comment  aligned to the same column.  Do not use tabs.  This provides
118 @comment  better formatting.
119 @comment
120 @menu
121 * Getting Started::      What you should know about GNU Fortran.
122 * GNU Fortran and GCC::  You can compile Fortran, C, or other programs.
123 * GNU Fortran and G77::  Why we chose to start from scratch.
124 * Invoking GNU Fortran:: Command options supported by @command{gfortran}.
125 * Project Status::       Status of GNU Fortran, roadmap, proposed extensions.
126 * Contributing::         How you can help.
127 * Standards::            Standards supported by GNU Fortran.
128 * Runtime::              Influencing runtime behavior with environment variables.
129 * Extensions::           Language extensions implemented by GNU Fortran.
130 * Intrinsic Procedures:: Intrinsic procedures supported by GNU Fortran.
131 * Copying::              GNU General Public License says
132                          how you can copy and share GNU Fortran.
133 * GNU Free Documentation License::
134                          How you can copy and share this manual.
135 * Funding::              How to help assure continued work for free software.
136 * Index::                Index of this documentation.
137 @end menu
138
139
140
141 @c ---------------------------------------------------------------------
142 @c Getting Started
143 @c ---------------------------------------------------------------------
144
145 @node Getting Started
146 @chapter Getting Started
147
148 The GNU Fortran compiler front end was
149 designed initially as a free replacement for,
150 or alternative to, the unix @command{f95} command;
151 @command{gfortran} is the command you'll use to invoke the compiler.
152
153 The GNU Fortran compiler is still in an early state of development.
154 It can generate code for most constructs and expressions,
155 but much work remains to be done.
156
157 When the GNU Fortran compiler is finished,
158 it will do everything you expect from any decent compiler: 
159
160 @itemize @bullet
161 @item
162 Read a user's program,
163 stored in a file and containing instructions written
164 in Fortran 77, Fortran 90 or Fortran 95.
165 This file contains @dfn{source code}.
166
167 @item
168 Translate the user's program into instructions a computer
169 can carry out more quickly than it takes to translate the
170 instructions in the first
171 place.  The result after compilation of a program is
172 @dfn{machine code},
173 code designed to be efficiently translated and processed
174 by a machine such as your computer.
175 Humans usually aren't as good writing machine code
176 as they are at writing Fortran (or C++, Ada, or Java),
177 because is easy to make tiny mistakes writing machine code.
178
179 @item
180 Provide the user with information about the reasons why
181 the compiler is unable to create a binary from the source code.
182 Usually this will be the case if the source code is flawed.
183 When writing Fortran, it is easy to make big mistakes.
184 The Fortran 90 requires that the compiler can point out
185 mistakes to the user.
186 An incorrect usage of the language causes an @dfn{error message}.
187
188 The compiler will also attempt to diagnose cases where the
189 user's program contains a correct usage of the language,
190 but instructs the computer to do something questionable.
191 This kind of diagnostics message is called a @dfn{warning message}.
192
193 @item
194 Provide optional information about the translation passes
195 from the source code to machine code.
196 This can help a user of the compiler to find the cause of
197 certain bugs which may not be obvious in the source code,
198 but may be more easily found at a lower level compiler output.
199 It also helps developers to find bugs in the compiler itself.
200
201 @item
202 Provide information in the generated machine code that can
203 make it easier to find bugs in the program (using a debugging tool,
204 called a @dfn{debugger}, such as the GNU Debugger @command{gdb}). 
205
206 @item
207 Locate and gather machine code already generated to
208 perform actions requested by statements in the user's program.
209 This machine code is organized into @dfn{modules} and is located
210 and @dfn{linked} to the user program. 
211 @end itemize
212
213 The GNU Fortran compiler consists of several components:
214
215 @itemize @bullet
216 @item
217 A version of the @command{gcc} command
218 (which also might be installed as the system's @command{cc} command)
219 that also understands and accepts Fortran source code.
220 The @command{gcc} command is the @dfn{driver} program for
221 all the languages in the GNU Compiler Collection (GCC);
222 With @command{gcc},
223 you can compile the source code of any language for
224 which a front end is available in GCC.
225
226 @item
227 The @command{gfortran} command itself,
228 which also might be installed as the
229 system's @command{f95} command.
230 @command{gfortran} is just another driver program,
231 but specifically for the Fortran compiler only.
232 The difference with @command{gcc} is that @command{gfortran}
233 will automatically link the correct libraries to your program.
234
235 @item
236 A collection of run-time libraries.
237 These libraries contain the machine code needed to support
238 capabilities of the Fortran language that are not directly
239 provided by the machine code generated by the
240 @command{gfortran} compilation phase,
241 such as intrinsic functions and subroutines,
242 and routines for interaction with files and the operating system.
243 @c and mechanisms to spawn,
244 @c unleash and pause threads in parallelized code.
245
246 @item
247 The Fortran compiler itself, (@command{f951}).
248 This is the GNU Fortran parser and code generator,
249 linked to and interfaced with the GCC backend library.
250 @command{f951} ``translates'' the source code to
251 assembler code.  You would typically not use this
252 program directly;
253 instead, the @command{gcc} or @command{gfortran} driver
254 programs will call it for you.
255 @end itemize
256
257
258
259 @c ---------------------------------------------------------------------
260 @c GNU Fortran and GCC
261 @c ---------------------------------------------------------------------
262
263 @node GNU Fortran and GCC
264 @chapter GNU Fortran and GCC
265 @cindex GNU Compiler Collection
266
267 GCC used to be the GNU ``C'' Compiler,
268 but is now known as the @dfn{GNU Compiler Collection}.
269 GCC provides the GNU system with a very versatile
270 compiler middle end (shared optimization passes),
271 and back ends (code generators) for many different
272 computer architectures and operating systems.
273 The code of the middle end and back end are shared by all
274 compiler front ends that are in the GNU Compiler Collection.
275
276 A GCC front end is essentially a source code parser
277 and an intermediate code generator.  The code generator translates the
278 semantics of the source code into a language independent form called
279 @dfn{GENERIC}.
280
281 The parser takes a source file written in a
282 particular computer language, reads and parses it,
283 and tries to make sure that the source code conforms to
284 the language rules.
285 Once the correctness of a program has been established,
286 the compiler will build a data structure known as the
287 @dfn{Abstract Syntax tree},
288 or just @dfn{AST} or ``tree'' for short.
289 This data structure represents the whole program
290 or a subroutine or a function.
291 The ``tree'' is passed to the GCC middle end,
292 which will perform optimization passes on it.  The optimized AST is then 
293 handed off too the back end which assembles the program unit.
294
295 Different phases in this translation process can be,
296 and in fact @emph{are} merged in many compiler front ends.
297 GNU Fortran has a strict separation between the
298 parser and code generator.
299
300 The goal of the GNU Fortran project is to build a new front end for GCC.
301 Specifically, a Fortran 95 front end.
302 In a non-@command{gfortran} installation,
303 @command{gcc} will not be able to compile Fortran source code
304 (only the ``C'' front end has to be compiled if you want to build GCC,
305 all other languages are optional).
306 If you build GCC with @command{gfortran}, @command{gcc} will recognize
307 @file{.f/.f90/.f95} source files and accepts Fortran specific
308 command line options.
309
310
311
312 @c ---------------------------------------------------------------------
313 @c GNU Fortran and G77
314 @c ---------------------------------------------------------------------
315
316 @node GNU Fortran and G77
317 @chapter GNU Fortran and G77
318 @cindex Fortran 77
319 @cindex G77
320
321 Why do we write a compiler front end from scratch? 
322 There's a fine Fortran 77 compiler in the
323 GNU Compiler Collection that accepts some features
324 of the Fortran 90 standard as extensions.
325 Why not start from there and revamp it?
326
327 One of the reasons is that Craig Burley, the author of G77,
328 has decided to stop working on the G77 front end.
329 On @uref{http://world.std.com/~burley/g77-why.html,
330 Craig explains the reasons for his decision to stop working on G77}
331 in one of the pages in his homepage.
332 Among the reasons is a lack of interest in improvements to
333 @command{g77}.
334 Users appear to be quite satisfied with @command{g77} as it is.
335 While @command{g77} is still being maintained (by Toon Moene),
336 it is unlikely that sufficient people will be willing
337 to completely rewrite the existing code. 
338
339 But there are other reasons to start from scratch.
340 Many people, including Craig Burley,
341 no longer agreed with certain design decisions in the G77 front end.
342 Also, the interface of @command{g77} to the back end is written in
343 a style which is confusing and not up to date on recommended practice.
344 In fact, a full rewrite had already been planned for GCC 3.0.
345
346 When Craig decided to stop,
347 it just seemed to be a better idea to start a new project from scratch,
348 because it was expected to be easier to maintain code we
349 develop ourselves than to do a major overhaul of @command{g77} first,
350 and then build a Fortran 95 compiler out of it.
351
352 @include invoke.texi
353
354 @c ---------------------------------------------------------------------
355 @c Project Status
356 @c ---------------------------------------------------------------------
357
358 @node Project Status
359 @chapter Project Status
360
361 @quotation
362 As soon as @command{gfortran} can parse all of the statements correctly,
363 it will be in the ``larva'' state.
364 When we generate code, the ``puppa'' state.
365 When @command{gfortran} is done,
366 we'll see if it will be a beautiful butterfly,
367 or just a big bug....
368
369 --Andy Vaught, April 2000
370 @end quotation
371
372 The start of the GNU Fortran 95 project was announced on
373 the GCC homepage in March 18, 2000
374 (even though Andy had already been working on it for a while,
375 of course).
376
377 @menu
378 * Compiler and Library Status::
379 * Proposed Extensions::
380 @end menu
381
382 @node Compiler and Library Status
383 @section Compiler and Library Status
384
385 The GNU Fortran compiler is able to compile nearly all
386 standard-compliant Fortran 95, Fortran 90, and Fortran 77 programs,
387 including a number of standard and non-standard extensions, and can be
388 used on real-world programs.  In particular, the supported extensions
389 include OpenMP, Cray-style pointers, and several Fortran 2003 features
390 such as enumeration, stream I/O, and some of the enhancements to
391 allocatable array support from TR 15581.  However, it is still under
392 development and has a few remaining rough edges.
393
394 At present, the GNU Fortran compiler passes the
395 @uref{http://www.fortran-2000.com/ArnaudRecipes/fcvs21_f95.html, 
396 NIST Fortran 77 Test Suite}, and produces acceptable results on the
397 @uref{http://www.netlib.org/lapack/faq.html#1.21, LAPACK Test Suite}.
398 It also provides respectable performance on 
399 the @uref{http://www.polyhedron.com/pb05.html, Polyhedron Fortran
400 compiler benchmarks} and the
401 @uref{http://www.llnl.gov/asci_benchmarks/asci/limited/lfk/README.html,
402 Livermore Fortran Kernels test}.  It has been used to compile a number of
403 large real-world programs, including
404 @uref{http://mysite.verizon.net/serveall/moene.pdf, the HIRLAM
405 weather-forecasting code} and
406 @uref{http://www.theochem.uwa.edu.au/tonto/, the Tonto quantum 
407 chemistry package}.
408
409 Among other things, the GNU Fortran compiler is intended as a replacement
410 for G77.  At this point, nearly all programs that could be compiled with
411 G77 can be compiled with GNU Fortran, although there are a few minor known
412 regressions.
413
414 The primary work remaining to be done on GNU Fortran falls into three
415 categories: bug fixing (primarily regarding the treatment of invalid code
416 and providing useful error messages), improving the compiler optimizations
417 and the performance of compiled code, and extending the compiler to support
418 future standards -- in particular, Fortran 2003.
419
420
421 @node Proposed Extensions
422 @section Proposed Extensions
423
424 Here's a list of proposed extensions for the GNU Fortran compiler, in no particular
425 order.  Most of these are necessary to be fully compatible with
426 existing Fortran compilers, but they are not part of the official
427 J3 Fortran 95 standard.
428
429 @subsection Compiler extensions: 
430 @itemize @bullet
431 @item
432 User-specified alignment rules for structures.
433
434 @item
435 Flag to generate @code{Makefile} info.
436
437 @item
438 Automatically extend single precision constants to double.
439
440 @item
441 Compile code that conserves memory by dynamically allocating common and
442 module storage either on stack or heap.
443
444 @item
445 Compile flag to generate code for array conformance checking (suggest -CC).
446
447 @item
448 User control of symbol names (underscores, etc).
449
450 @item
451 Compile setting for maximum size of stack frame size before spilling
452 parts to static or heap.
453
454 @item
455 Flag to force local variables into static space.
456
457 @item
458 Flag to force local variables onto stack.
459
460 @item
461 Flag for maximum errors before ending compile.
462
463 @item
464 Option to initialize otherwise uninitialized integer and floating
465 point variables.
466 @end itemize
467
468
469 @subsection Environment Options
470 @itemize @bullet
471 @item
472 Pluggable library modules for random numbers, linear algebra.
473 LA should use BLAS calling conventions.
474
475 @item
476 Environment variables controlling actions on arithmetic exceptions like
477 overflow, underflow, precision loss -- Generate NaN, abort, default.
478 action.
479
480 @item
481 Set precision for fp units that support it (i387).
482
483 @item
484 Variable for setting fp rounding mode.
485
486 @item
487 Variable to fill uninitialized variables with a user-defined bit
488 pattern.
489
490 @item
491 Environment variable controlling filename that is opened for that unit
492 number.
493
494 @item
495 Environment variable to clear/trash memory being freed.
496
497 @item
498 Environment variable to control tracing of allocations and frees.
499
500 @item
501 Environment variable to display allocated memory at normal program end.
502
503 @item
504 Environment variable for filename for * IO-unit.
505
506 @item
507 Environment variable for temporary file directory.
508
509 @item
510 Environment variable forcing standard output to be line buffered (unix).
511
512 @end itemize
513
514
515 @c ---------------------------------------------------------------------
516 @c Runtime
517 @c ---------------------------------------------------------------------
518
519 @node Runtime
520 @chapter Runtime:  Influencing runtime behavior with environment variables
521 @cindex Runtime
522
523 The behavior of the @command{gfortran} can be influenced by
524 environment variables.
525
526 Malformed environment variables are silently ignored.
527
528 @menu
529 * GFORTRAN_STDIN_UNIT:: Unit number for standard input
530 * GFORTRAN_STDOUT_UNIT:: Unit number for standard output
531 * GFORTRAN_STDERR_UNIT:: Unit number for standard error
532 * GFORTRAN_USE_STDERR:: Send library output to standard error
533 * GFORTRAN_TMPDIR:: Directory for scratch files
534 * GFORTRAN_UNBUFFERED_ALL:: Don't buffer output
535 * GFORTRAN_SHOW_LOCUS::  Show location for runtime errors
536 * GFORTRAN_OPTIONAL_PLUS:: Print leading + where permitted
537 * GFORTRAN_DEFAULT_RECL:: Default record length for new files
538 * GFORTRAN_LIST_SEPARATOR::  Separator for list output
539 * GFORTRAN_CONVERT_UNIT::  Set endianness for unformatted I/O
540 @end menu
541
542 @node GFORTRAN_STDIN_UNIT
543 @section @env{GFORTRAN_STDIN_UNIT}---Unit number for standard input
544
545 This environment variable can be used to select the unit number
546 preconnected to standard input.  This must be a positive integer.
547 The default value is 5.
548
549 @node GFORTRAN_STDOUT_UNIT
550 @section @env{GFORTRAN_STDOUT_UNIT}---Unit number for standard output
551
552 This environment variable can be used to select the unit number
553 preconnected to standard output.  This must be a positive integer.
554 The default value is 6.
555
556 @node GFORTRAN_STDERR_UNIT
557 @section @env{GFORTRAN_STDERR_UNIT}---Unit number for standard error
558
559 This environment variable can be used to select the unit number
560 preconnected to standard error.  This must be a positive integer.
561 The default value is 0.
562
563 @node GFORTRAN_USE_STDERR
564 @section @env{GFORTRAN_USE_STDERR}---Send library output to standard error
565
566 This environment variable controls where library output is sent.
567 If the first letter is @samp{y}, @samp{Y} or @samp{1}, standard
568 error is used. If the first letter is @samp{n}, @samp{N} or
569 @samp{0}, standard output is used.
570
571 @node GFORTRAN_TMPDIR
572 @section @env{GFORTRAN_TMPDIR}---Directory for scratch files
573
574 This environment variable controls where scratch files are
575 created.  If this environment variable is missing,
576 GNU Fortran searches for the environment variable @env{TMP}.  If
577 this is also missing, the default is @file{/tmp}.
578
579 @node GFORTRAN_UNBUFFERED_ALL
580 @section @env{GFORTRAN_UNBUFFERED_ALL}---Don't buffer output
581
582 This environment variable controls whether all output is unbuffered.
583 If the first letter is @samp{y}, @samp{Y} or @samp{1}, all output is
584 unbuffered. This will slow down large writes.  If the first letter is
585 @samp{n}, @samp{N}  or @samp{0}, output is buffered.  This is the
586 default.
587
588 @node GFORTRAN_SHOW_LOCUS
589 @section @env{GFORTRAN_SHOW_LOCUS}---Show location for runtime errors
590
591 If the first letter is @samp{y}, @samp{Y} or @samp{1}, filename and
592 line numbers for runtime errors are printed.  If the first letter is
593 @samp{n}, @samp{N} or @samp{0}, don't print filename and line numbers
594 for runtime errors. The default is to print the location.
595
596 @node GFORTRAN_OPTIONAL_PLUS
597 @section @env{GFORTRAN_OPTIONAL_PLUS}---Print leading + where permitted
598
599 If the first letter is @samp{y}, @samp{Y} or @samp{1},
600 a plus sign is printed
601 where permitted by the Fortran standard.  If the first letter
602 is @samp{n}, @samp{N} or @samp{0}, a plus sign is not printed
603 in most cases. Default is not to print plus signs.
604
605 @node GFORTRAN_DEFAULT_RECL
606 @section @env{GFORTRAN_DEFAULT_RECL}---Default record length for new files
607
608 This environment variable specifies the default record length for
609 files which are opened without a @code{RECL} tag in the @code{OPEN}
610 statement.  This must be a positive integer.  The default value is
611 1073741824.
612
613 @node GFORTRAN_LIST_SEPARATOR
614 @section @env{GFORTRAN_LIST_SEPARATOR}---Separator for list output
615
616 This environment variable specifies the separator when writing
617 list-directed output.  It may contain any number of spaces and
618 at most one comma.  If you specify this on the command line,
619 be sure to quote spaces, as in
620 @smallexample
621 $ GFORTRAN_LIST_SEPARATOR='  ,  ' ./a.out
622 @end smallexample
623 when @code{a.out} is the compiled Fortran program that you want to run.
624 Default is a single space.
625
626 @node GFORTRAN_CONVERT_UNIT
627 @section @env{GFORTRAN_CONVERT_UNIT}---Set endianness for unformatted I/O
628
629 By setting the @env{GFORTRAN_CONVERT_UNIT} variable, it is possible
630 to change the representation of data for unformatted files.
631 The syntax for the @env{GFORTRAN_CONVERT_UNIT} variable is:
632 @smallexample
633 GFORTRAN_CONVERT_UNIT: mode | mode ';' exception ;
634 mode: 'native' | 'swap' | 'big_endian' | 'little_endian' ;
635 exception: mode ':' unit_list | unit_list ;
636 unit_list: unit_spec | unit_list unit_spec ;
637 unit_spec: INTEGER | INTEGER '-' INTEGER ;
638 @end smallexample
639 The variable consists of an optional default mode, followed by
640 a list of optional exceptions, which are separated by semicolons
641 from the preceding default and each other.  Each exception consists
642 of a format and a comma-separated list of units.  Valid values for
643 the modes are the same as for the @code{CONVERT} specifier:
644
645 @itemize @w{}
646 @item @code{NATIVE} Use the native format.  This is the default.
647 @item @code{SWAP} Swap between little- and big-endian.
648 @item @code{LITTLE_ENDIAN} Use the little-endian format
649         for unformatted files.
650 @item @code{BIG_ENDIAN} Use the big-endian format for unformatted files.
651 @end itemize
652 A missing mode for an exception is taken to mean @code{BIG_ENDIAN}.
653 Examples of values for @code{GFORTRAN_CONVERT_UNIT} are:
654 @itemize @w{}
655 @item @code{'big_endian'}  Do all unformatted I/O in big_endian mode.
656 @item @code{'little_endian;native:10-20,25'}  Do all unformatted I/O 
657 in little_endian mode, except for units 10 to 20 and 25, which are in
658 native format.
659 @item @code{'10-20'}  Units 10 to 20 are big-endian, the rest is native.
660 @end itemize
661
662 Setting the environment variables should be done on the command
663 line or via the @code{export}
664 command for @code{sh}-compatible shells and via @code{setenv}
665 for @code{csh}-compatible shells.
666
667 Example for @code{sh}:
668 @smallexample
669 $ gfortran foo.f90
670 $ GFORTRAN_CONVERT_UNIT='big_endian;native:10-20' ./a.out
671 @end smallexample
672
673 Example code for @code{csh}:
674 @smallexample
675 % gfortran foo.f90
676 % setenv GFORTRAN_CONVERT_UNIT 'big_endian;native:10-20'
677 % ./a.out
678 @end smallexample
679
680 Using anything but the native representation for unformatted data
681 carries a significant speed overhead.  If speed in this area matters
682 to you, it is best if you use this only for data that needs to be
683 portable.
684
685 @xref{CONVERT specifier}, for an alternative way to specify the
686 data representation for unformatted files.  @xref{Runtime Options}, for
687 setting a default data representation for the whole program.  The
688 @code{CONVERT} specifier overrides the @code{-fconvert} compile options.
689
690 @c ---------------------------------------------------------------------
691 @c Extensions
692 @c ---------------------------------------------------------------------
693
694 @c Maybe this chapter should be merged with the 'Standards' section,
695 @c whenever that is written :-)
696
697 @node Extensions
698 @chapter Extensions
699 @cindex Extension
700
701 GNU Fortran implements a number of extensions over standard
702 Fortran. This chapter contains information on their syntax and
703 meaning.  There are currently two categories of GNU Fortran
704 extensions, those that provide functionality beyond that provided
705 by any standard, and those that are supported by GNU Fortran
706 purely for backward compatibility with legacy compilers.  By default,
707 @option{-std=gnu} allows the compiler to accept both types of
708 extensions, but to warn about the use of the latter.  Specifying
709 either @option{-std=f95} or @option{-std=f2003} disables both types
710 of extensions, and @option{-std=legacy} allows both without warning.
711
712 @menu
713 * Old-style kind specifications::
714 * Old-style variable initialization::
715 * Extensions to namelist::
716 * X format descriptor::
717 * Commas in FORMAT specifications::
718 * Missing period in FORMAT specifications::
719 * I/O item lists::
720 * Hexadecimal constants::
721 * Real array indices::
722 * Unary operators::
723 * Implicitly interconvert LOGICAL and INTEGER::
724 * Hollerith constants support::
725 * Cray pointers::
726 * CONVERT specifier::
727 * OpenMP::
728 @end menu
729
730 @node Old-style kind specifications
731 @section Old-style kind specifications
732 @cindex Kind specifications
733
734 GNU Fortran allows old-style kind specifications in
735 declarations. These look like:
736 @smallexample
737       TYPESPEC*k x,y,z
738 @end smallexample
739 where @code{TYPESPEC} is a basic type, and where @code{k} is a valid kind
740 number for that type. The statement then declares @code{x}, @code{y}
741 and @code{z} to be of type @code{TYPESPEC} with kind @code{k}. In
742 other words, it is equivalent to the standard conforming declaration
743 @smallexample
744       TYPESPEC(k) x,y,z
745 @end smallexample
746
747 @node Old-style variable initialization
748 @section Old-style variable initialization
749 @cindex Initialization
750
751 GNU Fortran allows old-style initialization of variables of the
752 form:
753 @smallexample
754       INTEGER*4 i/1/,j/2/
755       REAL*8 x(2,2) /3*0.,1./
756 @end smallexample
757 These are only allowed in declarations without double colons
758 (@code{::}), as these were introduced in Fortran 90 which also
759 introduced a new syntax for variable initializations. The syntax for
760 the individual initializers is as for the @code{DATA} statement, but
761 unlike in a @code{DATA} statement, an initializer only applies to the
762 variable immediately preceding. In other words, something like
763 @code{INTEGER I,J/2,3/} is not valid.
764
765 Examples of standard conforming code equivalent to the above example, are:
766 @smallexample
767 ! Fortran 90
768       INTEGER(4) :: i = 1, j = 2
769       REAL(8) :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
770 ! Fortran 77
771       INTEGER  i, j
772       DOUBLE PRECISION x(2,2)
773       DATA i,j,x /1,2,3*0.,1./
774 @end smallexample
775
776 Note that variables initialized in type declarations
777 automatically acquire the @code{SAVE} attribute.
778
779 @node Extensions to namelist
780 @section Extensions to namelist
781 @cindex Namelist
782
783 GNU Fortran fully supports the Fortran 95 standard for namelist I/O
784 including array qualifiers, substrings and fully qualified derived types.
785 The output from a namelist write is compatible with namelist read.  The
786 output has all names in upper case and indentation to column 1 after the
787 namelist name.  Two extensions are permitted:
788
789 Old-style use of $ instead of &
790 @smallexample
791 $MYNML
792  X(:)%Y(2) = 1.0 2.0 3.0
793  CH(1:4) = "abcd"
794 $END
795 @end smallexample
796
797 It should be noticed that the default terminator is / rather than &END.
798
799 Querying of the namelist when inputting from stdin. After at least
800 one space, entering ? sends to stdout the namelist name and the names of
801 the variables in the namelist:
802 @smallexample
803 ?
804
805 &mynml
806  x
807  x%y
808  ch
809 &end
810 @end smallexample
811
812 Entering =? outputs the namelist to stdout, as if WRITE (*,NML = mynml)
813 had been called:
814 @smallexample
815 =?
816
817 &MYNML
818  X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
819  X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
820  X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
821  CH=abcd,  /
822 @end smallexample
823
824 To aid this dialog, when input is from stdin, errors send their
825 messages to stderr and execution continues, even if IOSTAT is set.
826
827 PRINT namelist is permitted.  This causes an error if -std=f95 is used.
828 @smallexample
829 PROGRAM test_print
830   REAL, dimension (4)  ::  x = (/1.0, 2.0, 3.0, 4.0/)
831   NAMELIST /mynml/ x
832   PRINT mynml
833 END PROGRAM test_print
834 @end smallexample
835
836 Expanded namelist reads are permitted.  This causes an error if -std=f95
837 is used.  In the following example, the first element of the array will be
838 given the value 0.00 and succeeding elements will be 1.00 and 2.00.
839 @smallexample
840 &MYNML
841   X(1,1) = 0.00 , 1.00 , 2.00
842 /
843 @end smallexample
844
845 @node X format descriptor
846 @section X format descriptor
847 @cindex X format descriptor
848
849 To support legacy codes, GNU Fortran permits the count field
850 of the X edit descriptor in FORMAT statements to be omitted.  When
851 omitted, the count is implicitly assumed to be one.
852
853 @smallexample
854        PRINT 10, 2, 3
855 10     FORMAT (I1, X, I1)
856 @end smallexample
857
858 @node Commas in FORMAT specifications
859 @section Commas in FORMAT specifications
860 @cindex Commas in FORMAT specifications
861
862 To support legacy codes, GNU Fortran allows the comma separator
863 to be omitted immediately before and after character string edit
864 descriptors in FORMAT statements.
865
866 @smallexample
867        PRINT 10, 2, 3
868 10     FORMAT ('FOO='I1' BAR='I2)
869 @end smallexample
870
871
872 @node Missing period in FORMAT specifications
873 @section Missing period in FORMAT specifications
874 @cindex Missing period in FORMAT specifications
875
876 To support legacy codes, GNU Fortran allows missing periods in format
877 specifications if and only if -std=legacy is given on the command line.  This
878 is considered non-conforming code and is discouraged.
879
880 @smallexample
881        REAL :: value
882        READ(*,10) value
883 10     FORMAT ('F4')
884 @end smallexample
885
886 @node I/O item lists
887 @section I/O item lists
888 @cindex I/O item lists
889
890 To support legacy codes, GNU Fortran allows the input item list
891 of the READ statement, and the output item lists of the WRITE and PRINT
892 statements to start with a comma.
893
894 @node Hexadecimal constants
895 @section Hexadecimal constants
896 @cindex Hexadecimal constants
897
898 As an extension, GNU Fortran allows hexadecimal constants to
899 be specified using the X prefix, in addition to the standard Z prefix.
900 BOZ literal constants can also be specified by adding a suffix to the string.
901 For example, @code{Z'ABC'} and @code{'ABC'Z} are the same constant.
902
903 The Fortran standard restricts the appearance of a BOZ literal constant to
904 the @code{DATA} statement, and it is expected to be assigned to an 
905 @code{INTEGER} variable.  GNU Fortran permits a BOZ literal to appear
906 in any initialization expression as well as assignment statements.
907
908 Attempts to use a BOZ literal constant to do a bitwise initialization of a
909 variable can lead to confusion.  A BOZ literal constant is converted to an
910 @code{INTEGER} value with the kind type with the largest decimal representation,
911 and this value is then converted numerically to the type and kind of the
912 variable in question.  Thus, one should not expect a bitwise copy of the BOZ
913 literal constant to be assigned to a @code{REAL} variable.
914
915 Similarly, initializing an @code{INTEGER} variable with a statement such as
916 @code{DATA i/Z'FFFFFFFF'/} will produce an integer overflow rather than the
917 desired result of @math{-1} when @code{i} is a 32-bit integer on a system that
918 supports 64-bit integers.  The @samp{-fno-range-check} option can be used as 
919 a workaround for legacy code that initializes integers in this manner.
920
921
922 @node Real array indices
923 @section Real array indices
924 @cindex Real array indices
925
926 As an extension, GNU Fortran allows arrays to be indexed using
927 real types, whose values are implicitly converted to integers.
928
929 @node Unary operators
930 @section Unary operators
931 @cindex Unary operators
932
933 As an extension, GNU Fortran allows unary plus and unary
934 minus operators to appear as the second operand of binary arithmetic
935 operators without the need for parenthesis.
936
937 @smallexample
938        X = Y * -Z
939 @end smallexample
940
941 @node Implicitly interconvert LOGICAL and INTEGER
942 @section Implicitly interconvert LOGICAL and INTEGER
943 @cindex Implicitly interconvert LOGICAL and INTEGER
944
945 As an extension for backwards compatibility with other compilers,
946 GNU Fortran allows the implicit conversion of LOGICALs to INTEGERs
947 and vice versa.  When converting from a LOGICAL to an INTEGER, the numeric
948 value of @code{.FALSE.} is zero, and that of @code{.TRUE.} is one.  When
949 converting from INTEGER to LOGICAL, the value zero is interpreted as
950 @code{.FALSE.} and any nonzero value is interpreted as @code{.TRUE.}.
951
952 @smallexample
953        INTEGER*4 i
954        i = .FALSE.
955 @end smallexample
956
957 @node Hollerith constants support
958 @section Hollerith constants support
959 @cindex Hollerith constants
960
961 A Hollerith constant is a string of characters preceded by the letter @samp{H}
962 or @samp{h}, and there must be an literal, unsigned, nonzero default integer
963 constant indicating the number of characters in the string. Hollerith constants
964 are stored as byte strings, one character per byte.
965
966 GNU Fortran supports Hollerith constants. They can be used as the right
967 hands in the @code{DATA} statement and @code{ASSIGN} statement, also as the
968 arguments. The left hands can be of Integer, Real, Complex and Logical type.
969 The constant will be padded or truncated to fit the size of left hand.
970
971 Valid Hollerith constants examples:
972 @smallexample
973 complex*16 x(2)
974 data x /16Habcdefghijklmnop, 16Hqrstuvwxyz012345/
975 call foo (4H abc)
976 x(1) = 16Habcdefghijklmnop
977 @end smallexample
978
979 Invalid Hollerith constants examples:
980 @smallexample
981 integer*4 a
982 a = 8H12345678 ! The Hollerith constant is too long. It will be truncated.
983 a = 0H         ! At least one character needed.
984 @end smallexample
985
986 @node Cray pointers
987 @section Cray pointers
988 @cindex Cray pointers
989
990 Cray pointers are part of a non-standard extension that provides a
991 C-like pointer in Fortran.  This is accomplished through a pair of
992 variables: an integer "pointer" that holds a memory address, and a
993 "pointee" that is used to dereference the pointer.
994
995 Pointer/pointee pairs are declared in statements of the form:
996 @smallexample
997         pointer ( <pointer> , <pointee> )
998 @end smallexample
999 or,
1000 @smallexample
1001         pointer ( <pointer1> , <pointee1> ), ( <pointer2> , <pointee2> ), ...
1002 @end smallexample
1003 The pointer is an integer that is intended to hold a memory address.
1004 The pointee may be an array or scalar.  A pointee can be an assumed
1005 size array -- that is, the last dimension may be left unspecified by
1006 using a '*' in place of a value -- but a pointee cannot be an assumed
1007 shape array.  No space is allocated for the pointee.
1008
1009 The pointee may have its type declared before or after the pointer
1010 statement, and its array specification (if any) may be declared
1011 before, during, or after the pointer statement.  The pointer may be
1012 declared as an integer prior to the pointer statement.  However, some
1013 machines have default integer sizes that are different than the size
1014 of a pointer, and so the following code is not portable:
1015 @smallexample
1016         integer ipt
1017         pointer (ipt, iarr)
1018 @end smallexample
1019 If a pointer is declared with a kind that is too small, the compiler
1020 will issue a warning; the resulting binary will probably not work
1021 correctly, because the memory addresses stored in the pointers may be
1022 truncated.  It is safer to omit the first line of the above example;
1023 if explicit declaration of ipt's type is omitted, then the compiler
1024 will ensure that ipt is an integer variable large enough to hold a
1025 pointer.
1026
1027 Pointer arithmetic is valid with Cray pointers, but it is not the same
1028 as C pointer arithmetic.  Cray pointers are just ordinary integers, so
1029 the user is responsible for determining how many bytes to add to a
1030 pointer in order to increment it.  Consider the following example:
1031 @smallexample
1032         real target(10)
1033         real pointee(10)
1034         pointer (ipt, pointee)
1035         ipt = loc (target)
1036         ipt = ipt + 1       
1037 @end smallexample
1038 The last statement does not set ipt to the address of
1039 @code{target(1)}, as one familiar with C pointer arithmetic might
1040 expect.  Adding 1 to ipt just adds one byte to the address stored in
1041 ipt.
1042
1043 Any expression involving the pointee will be translated to use the
1044 value stored in the pointer as the base address.
1045
1046 To get the address of elements, this extension provides an intrinsic
1047 function loc(), loc() is essentially the C '&' operator, except the
1048 address is cast to an integer type:
1049 @smallexample
1050         real ar(10)
1051         pointer(ipt, arpte(10))
1052         real arpte
1053         ipt = loc(ar)  ! Makes arpte is an alias for ar
1054         arpte(1) = 1.0 ! Sets ar(1) to 1.0
1055 @end smallexample
1056 The pointer can also be set by a call to the @code{MALLOC} intrinsic
1057 (see @ref{MALLOC}).
1058
1059 Cray pointees often are used to alias an existing variable.  For
1060 example:
1061 @smallexample
1062         integer target(10)
1063         integer iarr(10)
1064         pointer (ipt, iarr)
1065         ipt = loc(target)
1066 @end smallexample
1067 As long as ipt remains unchanged, iarr is now an alias for target.
1068 The optimizer, however, will not detect this aliasing, so it is unsafe
1069 to use iarr and target simultaneously.  Using a pointee in any way
1070 that violates the Fortran aliasing rules or assumptions is illegal.
1071 It is the user's responsibility to avoid doing this; the compiler
1072 works under the assumption that no such aliasing occurs.
1073
1074 Cray pointers will work correctly when there is no aliasing (i.e.,
1075 when they're used to access a dynamically allocated block of memory),
1076 and also in any routine where a pointee is used, but any variable with
1077 which it shares storage is not used.  Code that violates these rules
1078 may not run as the user intends.  This is not a bug in the optimizer;
1079 any code that violates the aliasing rules is illegal.  (Note that this
1080 is not unique to GNU Fortran; any Fortran compiler that supports Cray
1081 pointers will ``incorrectly'' optimize code with illegal aliasing.)
1082
1083 There are a number of restrictions on the attributes that can be
1084 applied to Cray pointers and pointees.  Pointees may not have the
1085 attributes ALLOCATABLE, INTENT, OPTIONAL, DUMMY, TARGET,
1086 INTRINSIC, or POINTER.  Pointers may not have the attributes
1087 DIMENSION, POINTER, TARGET, ALLOCATABLE, EXTERNAL, or INTRINSIC.
1088 Pointees may not occur in more than one pointer statement.  A pointee
1089 cannot be a pointer.  Pointees cannot occur in equivalence, common, or
1090 data statements.
1091
1092 A Cray pointer may point to a function or a subroutine.  For example,
1093 the following excerpt is valid:
1094 @smallexample
1095   implicit none
1096   external sub
1097   pointer (subptr,subpte)
1098   external subpte
1099   subptr = loc(sub)
1100   call subpte()
1101   [...]
1102   subroutine sub
1103   [...]
1104   end subroutine sub
1105 @end smallexample
1106
1107 A pointer may be modified during the course of a program, and this
1108 will change the location to which the pointee refers.  However, when
1109 pointees are passed as arguments, they are treated as ordinary
1110 variables in the invoked function.  Subsequent changes to the pointer
1111 will not change the base address of the array that was passed.
1112
1113 @node CONVERT specifier
1114 @section CONVERT specifier
1115 @cindex CONVERT specifier
1116
1117 GNU Fortran allows the conversion of unformatted data between little-
1118 and big-endian representation to facilitate moving of data
1119 between different systems.  The conversion can be indicated with
1120 the @code{CONVERT} specifier on the @code{OPEN} statement.
1121 @xref{GFORTRAN_CONVERT_UNIT}, for an alternative way of specifying
1122 the data format via an environment variable.
1123
1124 Valid values for @code{CONVERT} are:
1125 @itemize @w{}
1126 @item @code{CONVERT='NATIVE'} Use the native format.  This is the default.
1127 @item @code{CONVERT='SWAP'} Swap between little- and big-endian.
1128 @item @code{CONVERT='LITTLE_ENDIAN'} Use the little-endian representation
1129         for unformatted files.
1130 @item @code{CONVERT='BIG_ENDIAN'} Use the big-endian representation for
1131         unformatted files.
1132 @end itemize
1133
1134 Using the option could look like this:
1135 @smallexample
1136   open(file='big.dat',form='unformatted',access='sequential', &
1137        convert='big_endian')
1138 @end smallexample
1139
1140 The value of the conversion can be queried by using
1141 @code{INQUIRE(CONVERT=ch)}.  The values returned are
1142 @code{'BIG_ENDIAN'} and @code{'LITTLE_ENDIAN'}.
1143
1144 @code{CONVERT} works between big- and little-endian for
1145 @code{INTEGER} values of all supported kinds and for @code{REAL}
1146 on IEEE systems of kinds 4 and 8.  Conversion between different
1147 ``extended double'' types on different architectures such as
1148 m68k and x86_64, which GNU Fortran
1149 supports as @code{REAL(KIND=10)}, will probably not work.
1150
1151 @emph{Note that the values specified via the GFORTRAN_CONVERT_UNIT
1152 environment variable will override the CONVERT specifier in the
1153 open statement}.  This is to give control over data formats to
1154 a user who does not have the source code of his program available.
1155
1156 Using anything but the native representation for unformatted data
1157 carries a significant speed overhead.  If speed in this area matters
1158 to you, it is best if you use this only for data that needs to be
1159 portable.
1160
1161 @node OpenMP
1162 @section OpenMP
1163 @cindex OpenMP
1164
1165 GNU Fortran attempts to be OpenMP Application Program Interface v2.5
1166 compatible when invoked with the @code{-fopenmp} option.  GNU Fortran
1167 then generates parallelized code according to the OpenMP directives
1168 used in the source.  The OpenMP Fortran runtime library
1169 routines are provided both in a form of Fortran 90 module named
1170 @code{omp_lib} and in a form of a Fortran @code{include} file named
1171 @code{omp_lib.h}.
1172
1173 For details refer to the actual
1174 @uref{http://www.openmp.org/drupal/mp-documents/spec25.pdf,
1175 OpenMP Application Program Interface v2.5} specification.
1176
1177 @c ---------------------------------------------------------------------
1178 @include intrinsic.texi
1179 @c ---------------------------------------------------------------------
1180
1181 @c ---------------------------------------------------------------------
1182 @c Contributing
1183 @c ---------------------------------------------------------------------
1184
1185 @node Contributing
1186 @chapter Contributing
1187 @cindex Contributing
1188
1189 Free software is only possible if people contribute to efforts
1190 to create it.
1191 We're always in need of more people helping out with ideas
1192 and comments, writing documentation and contributing code.
1193
1194 If you want to contribute to GNU Fortran,
1195 have a look at the long lists of projects you can take on.
1196 Some of these projects are small,
1197 some of them are large;
1198 some are completely orthogonal to the rest of what is
1199 happening on GNU Fortran,
1200 but others are ``mainstream'' projects in need of enthusiastic hackers.
1201 All of these projects are important!
1202 We'll eventually get around to the things here,
1203 but they are also things doable by someone who is willing and able.
1204
1205 @menu
1206 * Contributors::
1207 * Projects::
1208 @end menu
1209
1210
1211 @node Contributors
1212 @section Contributors to GNU Fortran
1213 @cindex Contributors
1214 @cindex Credits
1215 @cindex Authors
1216
1217 Most of the parser was hand-crafted by @emph{Andy Vaught}, who is
1218 also the initiator of the whole project.  Thanks Andy!
1219 Most of the interface with GCC was written by @emph{Paul Brook}.
1220
1221 The following individuals have contributed code and/or
1222 ideas and significant help to the GNU Fortran project
1223 (in no particular order):
1224
1225 @itemize @minus
1226 @item Andy Vaught
1227 @item Katherine Holcomb
1228 @item Tobias Schl@"uter
1229 @item Steven Bosscher
1230 @item Toon Moene
1231 @item Tim Prince
1232 @item Niels Kristian Bech Jensen
1233 @item Steven Johnson
1234 @item Paul Brook
1235 @item Feng Wang
1236 @item Bud Davis
1237 @item Paul Thomas
1238 @item Fran@,{c}ois-Xavier Coudert
1239 @item Steven G. Kargl
1240 @item Jerry Delisle
1241 @item Janne Blomqvist
1242 @item Erik Edelmann
1243 @item Thomas Koenig
1244 @item Asher Langton
1245 @item Jakub Jelinek
1246 @item Roger Sayle
1247 @item H.J. Lu
1248 @item Richard Henderson
1249 @item Richard Sandiford
1250 @item Richard Guenther
1251 @item Bernhard Fischer
1252 @end itemize
1253
1254 The following people have contributed bug reports,
1255 smaller or larger patches,
1256 and much needed feedback and encouragement for the
1257 GNU Fortran project: 
1258
1259 @itemize @minus
1260 @item Erik Schnetter
1261 @item Bill Clodius
1262 @item Kate Hedstrom
1263 @end itemize
1264
1265 Many other individuals have helped debug,
1266 test and improve the GNU Fortran compiler over the past few years,
1267 and we welcome you to do the same!
1268 If you already have done so,
1269 and you would like to see your name listed in the
1270 list above, please contact us.
1271
1272
1273 @node Projects
1274 @section Projects
1275
1276 @table @emph
1277
1278 @item Help build the test suite
1279 Solicit more code for donation to the test suite.
1280 We can keep code private on request.
1281
1282 @item Bug hunting/squishing
1283 Find bugs and write more test cases!
1284 Test cases are especially very welcome,
1285 because it allows us to concentrate on fixing bugs
1286 instead of isolating them.
1287
1288 @item Smaller projects (``bug'' fixes):
1289   @itemize @minus
1290   @item Allow init exprs to be numbers raised to integer powers.
1291   @item Implement correct rounding.
1292   @item Implement F restrictions on Fortran 95 syntax.
1293   @item See about making Emacs-parsable error messages.
1294   @end itemize
1295 @end table
1296
1297 If you wish to work on the runtime libraries,
1298 please contact a project maintainer.
1299 @c TODO: email!
1300
1301
1302 @c ---------------------------------------------------------------------
1303 @c Standards
1304 @c ---------------------------------------------------------------------
1305
1306 @node Standards
1307 @chapter Standards
1308 @cindex Standards
1309
1310 The GNU Fortran compiler implements
1311 ISO/IEC 1539:1997 (Fortran 95).  As such, it can also compile essentially all
1312 standard-compliant Fortran 90 and Fortran 77 programs.   It also supports
1313 the ISO/IEC TR-15581 enhancements to allocatable arrays, and
1314 the @uref{http://www.openmp.org/drupal/mp-documents/spec25.pdf,
1315 OpenMP Application Program Interface v2.5} specification.
1316
1317 In the future, the GNU Fortran compiler may also support other standard 
1318 variants of and extensions to the Fortran language.  These include
1319 ISO/IEC 1539-1:2004 (Fortran 2003).
1320
1321 @menu
1322 * Fortran 2003 status::
1323 @end menu
1324
1325 @node Fortran 2003 status
1326 @section Fortran 2003 status
1327
1328 Although GNU Fortran focuses on implementing the Fortran 95
1329 standard for the time being, a few Fortran 2003 features are currently
1330 available.
1331
1332 @itemize
1333 @item 
1334 Intrinsics @code{command_argument_count}, @code{get_command},
1335 @code{get_command_argument}, @code{get_environment_variable}, and
1336 @code{move_alloc}.
1337
1338 @item 
1339 @cindex Array constructors
1340 @cindex @code{[...]}
1341 Array constructors using square brackets. That is, @code{[...]} rather
1342 than @code{(/.../)}.
1343
1344 @item
1345 @cindex @code{FLUSH} statement
1346 @code{FLUSH} statement.
1347
1348 @item
1349 @cindex @code{IOMSG=} specifier
1350 @code{IOMSG=} specifier for I/O statements.
1351
1352 @item
1353 @cindex @code{ENUM} statement
1354 @cindex @code{ENUMERATOR} statement
1355 @cindex @command{-fshort-enums}
1356 Support for the declaration of enumeration constants via the
1357 @code{ENUM} and @code{ENUMERATOR} statements.  Interoperability with
1358 @command{gcc} is guaranteed also for the case where the
1359 @command{-fshort-enums} command line option is given.
1360
1361 @item
1362 @cindex TR 15581
1363 TR 15581:
1364 @itemize
1365 @item
1366 @cindex @code{ALLOCATABLE} dummy arguments
1367 @code{ALLOCATABLE} dummy arguments.
1368 @item
1369 @cindex @code{ALLOCATABLE} function results
1370 @code{ALLOCATABLE} function results
1371 @item
1372 @cindex @code{ALLOCATABLE} components of derived types
1373 @code{ALLOCATABLE} components of derived types
1374 @end itemize
1375
1376 @item
1377 @cindex @code{STREAM} I/O
1378 @cindex @code{ACCESS='STREAM'} I/O
1379 The @code{OPEN} statement supports the @code{ACCESS='STREAM'} specifier,
1380 allowing I/O without any record structure.
1381
1382
1383
1384 @end itemize
1385
1386
1387 @c ---------------------------------------------------------------------
1388 @c GNU General Public License
1389 @c ---------------------------------------------------------------------
1390
1391 @include gpl.texi
1392
1393
1394
1395 @c ---------------------------------------------------------------------
1396 @c GNU Free Documentation License
1397 @c ---------------------------------------------------------------------
1398
1399 @include fdl.texi
1400
1401
1402
1403 @c ---------------------------------------------------------------------
1404 @c Funding Free Software
1405 @c ---------------------------------------------------------------------
1406
1407 @include funding.texi
1408
1409 @c ---------------------------------------------------------------------
1410 @c Index
1411 @c ---------------------------------------------------------------------
1412
1413 @node Index
1414 @unnumbered Index
1415
1416 @printindex cp
1417
1418 @bye