gfortran.texi

gcc-fortran,linux使用fortran的编译软件。很好用的。

overhead occurs) or generate function calls (good for large arrays as it
allows use of hand-optimized assembly routines, SIMD instructions, etc.)

The IO library is in a mostly usable state.  Unformatted I/O for
@code{REAL(KIND=10)} variables is currently not recommended.

Array intrinsics mostly work.

@node Proposed Extensions
@section Proposed Extensions

Here's a list of proposed extensions for @command{gfortran}, in no particular
order.  Most of these are necessary to be fully compatible with
existing Fortran compilers, but they are not part of the official
J3 Fortran 95 standard.

@subsection Compiler extensions: 
@itemize @bullet
@item
Flag for defining the kind number for default logicals.

@item
User-specified alignment rules for structures.
@item
Flag to generate @code{Makefile} info.

@item
Automatically extend single precision constants to double.

@item
Compile code that conserves memory by dynamically allocating common and
module storage either on stack or heap.

@item
Flag to cause the compiler to distinguish between upper and lower case
names.  The Fortran 95 standard does not distinguish them.

@item
Compile flag to generate code for array conformance checking (suggest -CC).

@item
User control of symbol names (underscores, etc).

@item
Compile setting for maximum size of stack frame size before spilling
parts to static or heap.

@item
Flag to force local variables into static space.

@item
Flag to force local variables onto stack.

@item
Flag to compile lines beginning with ``D''.

@item
Flag to ignore lines beginning with ``D''.

@item
Flag for maximum errors before ending compile.

@item
Generate code to check for null pointer dereferences -- prints locus of
dereference instead of segfaulting.  There was some discussion about this
option in the g95 development mailing list.

@item
Allow setting the default unit number.

@item
Option to initialize otherwise uninitialized integer and floating
point variables.

@item
Support for OpenMP directives.  This also requires support from the runtime
library and the rest of the compiler.

@item
Support for Fortran 200x. This includes several new features including
floating point exceptions, extended use of allocatable arrays, C
interoperability, Parameterizer data types and function pointers.
@end itemize


@subsection Environment Options
@itemize @bullet
@item
Pluggable library modules for random numbers, linear algebra.
LA should use BLAS calling conventions.

@item
Environment variables controlling actions on arithmetic exceptions like
overflow, underflow, precision loss -- Generate NaN, abort, default.
action.

@item
Set precision for fp units that support it (i387).

@item
Variable for setting fp rounding mode.

@item
Variable to fill uninitialized variables with a user-defined bit
pattern.

@item
Environment variable controlling filename that is opened for that unit
number.

@item
Environment variable to clear/trash memory being freed.

@item
Environment variable to control tracing of allocations and frees.

@item
Environment variable to display allocated memory at normal program end.

@item
Environment variable for filename for * IO-unit.

@item
Environment variable for temporary file directory.

@item
Environment variable forcing standard output to be line buffered (unix).

@end itemize

@node Runtime
@chapter Runtime:  Influencing runtime behavior with environment variables
@cindex Runtime

The behaviour of the @command{gfortran} can be influenced by
environment variables.
@menu
* GFORTRAN_CONVERT_UNIT::  Set endianness for unformatted I/O
@end menu

@node GFORTRAN_CONVERT_UNIT
@section GFORTRAN_CONVERT_UNIT --- Set endianness for unformatted I/O

By setting the @code{GFORTRAN_CONVERT_UNIT variable}, it is possible
to change the representation of data for unformatted files.
The syntax for the @code{GFORTRAN_CONVERT_UNIT} variable is:
@smallexample
GFORTRAN_CONVERT_UNIT: mode | mode ';' exception ;
mode: 'native' | 'swap' | 'big_endian' | 'little_endian' ;
exception: mode ':' unit_list | unit_list ;
unit_list: unit_spec | unit_list unit_spec ;
unit_spec: INTEGER | INTEGER '-' INTEGER ;
@end smallexample
The variable consists of an optional default mode, followed by
a list of optional exceptions, which are separated by semicolons
from the preceding default and each other.  Each exception consists
of a format and a comma-separated list of units.  Valid values for
the modes are the same as for the @code{CONVERT} specifier:

@itemize @w{}
@item @code{NATIVE} Use the native format.  This is the default.
@item @code{SWAP} Swap between little- and big-endian.
@item @code{LITTLE_ENDIAN} Use the little-endian format
        for unformatted files.
@item @code{BIG_ENDIAN} Use the big-endian format for unformatted files.
@end itemize
A missing mode for an exception is taken to mean @code{BIG_ENDIAN}.
Examples of values for @code{GFORTRAN_CONVERT_UNIT} are:
@itemize @w{}
@item @code{'big_endian'}  Do all unformatted I/O in big_endian mode.
@item @code{'little_endian;native:10-20,25'}  Do all unformatted I/O 
in little_endian mode, except for units 10 to 20 and 25, which are in
native format.
@item @code{'10-20'}  Units 10 to 20 are big-endian, the rest is native.
@end itemize

Setting the environment variables should be done on the command
line or via the @code{export}
command for @code{sh}-compatible shells and via @code{setenv}
for @code{csh}-compatible shells.

Example for @code{sh}:
@smallexample
$ gfortran foo.f90
$ GFORTRAN_CONVERT_UNIT='big_endian;native:10-20' ./a.out
@end smallexample

Example code for @code{csh}:
@smallexample
% gfortran foo.f90
% setenv GFORTRAN_CONVERT_UNIT 'big_endian;native:10-20'
% ./a.out
@end smallexample

Using anything but the native representation for unformatted data
carries a significant speed overhead.  If speed in this area matters
to you, it is best if you use this only for data that needs to be
portable.

@xref{CONVERT specifier}, for an alternative way to specify the
data representation for unformatted files.  @xref{Runtime Options}, for
setting a default data representation for the whole program.  The
@code{CONVERT} specifier overrides the @code{-fconvert} compile options.

@c ---------------------------------------------------------------------
@c Extensions
@c ---------------------------------------------------------------------

@c Maybe this chapter should be merged with the 'Standards' section,
@c whenever that is written :-)

@node Extensions
@chapter Extensions
@cindex Extension

@command{gfortran} implements a number of extensions over standard
Fortran. This chapter contains information on their syntax and
meaning.  There are currently two categories of @command{gfortran}
extensions, those that provide functionality beyond that provided
by any standard, and those that are supported by @command{gfortran}
purely for backward compatibility with legacy compilers.  By default,
@option{-std=gnu} allows the compiler to accept both types of
extensions, but to warn about the use of the latter.  Specifying
either @option{-std=f95} or @option{-std=f2003} disables both types
of extensions, and @option{-std=legacy} allows both without warning.

@menu
* Old-style kind specifications::
* Old-style variable initialization::
* Extensions to namelist::
* X format descriptor::
* Commas in FORMAT specifications::
* I/O item lists::
* Hexadecimal constants::
* Real array indices::
* Unary operators::
* Implicitly interconvert LOGICAL and INTEGER::
* Hollerith constants support::
* Cray pointers::
* CONVERT specifier::
@end menu

@node Old-style kind specifications
@section Old-style kind specifications
@cindex Kind specifications

@command{gfortran} allows old-style kind specifications in
declarations. These look like:
@smallexample
      TYPESPEC*k x,y,z
@end smallexample
where @code{TYPESPEC} is a basic type, and where @code{k} is a valid kind
number for that type. The statement then declares @code{x}, @code{y}
and @code{z} to be of type @code{TYPESPEC} with kind @code{k}. In
other words, it is equivalent to the standard conforming declaration
@smallexample
      TYPESPEC(k) x,y,z
@end smallexample

@node Old-style variable initialization
@section Old-style variable initialization
@cindex Initialization

@command{gfortran} allows old-style initialization of variables of the
form:
@smallexample
      INTEGER*4 i/1/,j/2/
      REAL*8 x(2,2) /3*0.,1./
@end smallexample
These are only allowed in declarations without double colons
(@code{::}), as these were introduced in Fortran 90 which also
introduced a new syntax for variable initializations. The syntax for
the individual initializers is as for the @code{DATA} statement, but
unlike in a @code{DATA} statement, an initializer only applies to the
variable immediately preceding. In other words, something like
@code{INTEGER I,J/2,3/} is not valid.

Examples of standard conforming code equivalent to the above example, are:
@smallexample
! Fortran 90
      INTEGER(4) :: i = 1, j = 2
      REAL(8) :: x(2,2) = RESHAPE((/0.,0.,0.,1./),SHAPE(x))
! Fortran 77
      INTEGER  i, j
      DOUBLE PRECISION x(2,2)
      DATA i,j,x /1,2,3*0.,1./
@end smallexample

@node Extensions to namelist
@section Extensions to namelist
@cindex Namelist

@command{gfortran} fully supports the Fortran 95 standard for namelist I/O
including array qualifiers, substrings and fully qualified derived types.
The output from a namelist write is compatible with namelist read.  The
output has all names in upper case and indentation to column 1 after the
namelist name.  Two extensions are permitted:

Old-style use of $ instead of &
@smallexample
$MYNML
 X(:)%Y(2) = 1.0 2.0 3.0
 CH(1:4) = "abcd"
$END
@end smallexample

It should be noticed that the default terminator is / rather than &END.

Querying of the namelist when inputting from stdin. After at least
one space, entering ? sends to stdout the namelist name and the names of
the variables in the namelist:
@smallexample
?

&mynml
 x
 x%y
 ch
&end
@end smallexample

Entering =? outputs the namelist to stdout, as if WRITE (*,NML = mynml)
had been called:
@smallexample
=?

&MYNML
 X(1)%Y=  0.000000    ,  1.000000    ,  0.000000    ,
 X(2)%Y=  0.000000    ,  2.000000    ,  0.000000    ,
 X(3)%Y=  0.000000    ,  3.000000    ,  0.000000    ,
 CH=abcd,  /
@end smallexample

To aid this dialog, when input is from stdin, errors send their
messages to stderr and execution continues, even if IOSTAT is set.

PRINT namelist is permitted.  This causes an error if -std=f95 is used.
@smallexample
PROGRAM test_print
  REAL, dimension (4)  ::  x = (/1.0, 2.0, 3.0, 4.0/)
  NAMELIST /mynml/ x
  PRINT mynml
END PROGRAM test_print
@end smallexample

@node X format descriptor
@section X format descriptor
@cindex X format descriptor

To support legacy codes, @command{gfortran} permits the count field
of the X edit descriptor in FORMAT statements to be omitted.  When
omitted, the count is implicitly assumed to be one.

@smallexample
       PRINT 10, 2, 3
10     FORMAT (I1, X, I1)
@end smallexample

@node Commas in FORMAT specifications
@section Commas in FORMAT specifications
@cindex Commas in FORMAT specifications

To support legacy codes, @command{gfortran} allows the comma separator
to be omitted immediately before and after character string edit
descriptors in FORMAT statements.

@smallexample
       PRINT 10, 2, 3
10     FORMAT ('FOO='I1' BAR='I2)
@end smallexample

@node I/O item lists
@section I/O item lists
@cindex I/O item lists

To support legacy codes, @command{gfortran} allows the input item list
of the READ statement, and the output item lists of the WRITE and PRINT
statements to start with a comma.

@node Hexadecimal constants
@section Hexadecimal constants
@cindex Hexadecimal constants

As a GNU extension, @command{gfortran} allows hexadecimal constants to
be specified using the X prefix, in addition to the standard Z prefix.

@node Real array indices
@section Real array indices
@cindex Real array indices

As a GNU extension, @command{gfortran} allows arrays to be indexed using
real types, whose values are implicitly converted to integers.

@node Unary operators
@section Unary operators
@cindex Unary operators

As a GNU extension, @command{gfortran} allows unary plus and unary
minus operators to appear as the second operand of binary arithmetic
operators without the need for parenthesis.

@smallexample
       X = Y * -Z
@end smallexample

@node Implicitly interconvert LOGICAL and INTEGER
@section Implicitly interconvert LOGICAL and INTEGER
@cindex Implicitly interconvert LOGICAL and INTEGER

As a GNU extension for backwards compatibility with other compilers,
@command{gfortran} allows the implicit conversion of LOGICALs to INTEGERs
and vice versa.  When converting from a LOGICAL to an INTEGER, the numeric
value of @code{.FALSE.} is zero, and that of @code{.TRUE.} is one.  When
converting from INTEGER to LOGICAL, the value zero is interpreted as
@code{.FALSE.} and any nonzero value is interpreted as @code{.TRUE.}.

@smallexample
       INTEGER*4 i
       i = .FALSE.
@end smallexample