Options Controlling Fortran Dialect

The following options control the dialect of Fortran that the compiler accepts:

-ffree-form

-fno-fixed-form

Specify that the source file is written in free form (introduced in Fortran 90) instead of the more-traditional fixed form.

-ff90

Allow certain Fortran-90 constructs.

This option controls whether certain Fortran 90 constructs are recognized. (Other Fortran 90 constructs might or might not be recognized depending on other options such as -fvxt, -ff90-intrinsics-enable, and the current level of support for Fortran 90.)

See Fortran 90, for more information.

-fvxt

Specify the treatment of certain constructs that have different meanings depending on whether the code is written in GNU Fortran (based on FORTRAN 77 and akin to Fortran 90) or VXT Fortran (more like VAX FORTRAN).

The default is -fno-vxt. -fvxt specifies that the VXT Fortran interpretations for those constructs are to be chosen.

See VXT Fortran, for more information.

-fdollar-ok

Allow $ as a valid character in a symbol name.

-fno-backslash

Specify that \ is not to be specially interpreted in character and Hollerith constants a la C and many UNIX Fortran compilers.

For example, with -fbackslash in effect, A\nB specifies three characters, with the second one being newline. With -fno-backslash, it specifies four characters, A, \, n, and B.

Note that g77 implements a fairly general form of backslash processing that is incompatible with the narrower forms supported by some other compilers. For example, 'A\003B' is a three-character string in g77 whereas other compilers that support backslash might not support the three-octal-digit form, and thus treat that string as longer than three characters.

See Backslash in Constants, for information on why -fbackslash is the default instead of -fno-backslash.

-fno-ugly-args

Disallow passing Hollerith and typeless constants as actual arguments (for example, CALL FOO(4HABCD)).

See Ugly Implicit Argument Conversion, for more information.

-fugly-assign

Use the same storage for a given variable regardless of whether it is used to hold an assigned-statement label (as in ASSIGN 10 TO I) or used to hold numeric data (as in I = 3).

See Ugly Assigned Labels, for more information.

-fugly-assumed

Assume any dummy array with a final dimension specified as 1 is really an assumed-size array, as if * had been specified for the final dimension instead of 1.

For example, DIMENSION X(1) is treated as if it had read DIMENSION X(*).

See Ugly Assumed-Size Arrays, for more information.

-fugly-comma

In an external-procedure invocation, treat a trailing comma in the argument list as specification of a trailing null argument, and treat an empty argument list as specification of a single null argument.

For example, CALL FOO(,) is treated as CALL FOO(%VAL(0), %VAL(0)). That is, two null arguments are specified by the procedure call when -fugly-comma is in force. And F = FUNC() is treated as F = FUNC(%VAL(0)).

The default behavior, -fno-ugly-comma, is to ignore a single trailing comma in an argument list. So, by default, CALL FOO(X,) is treated exactly the same as CALL FOO(X).

See Ugly Null Arguments, for more information.

-fugly-complex

Do not complain about REAL(expr) or AIMAG(expr) when expr is a COMPLEX type other than COMPLEX(KIND=1)--usually this is used to permit COMPLEX(KIND=2) (DOUBLE COMPLEX) operands.

The -ff90 option controls the interpretation of this construct.

See Ugly Complex Part Extraction, for more information.

-fno-ugly-init

Disallow use of Hollerith and typeless constants as initial values (in PARAMETER and DATA statements), and use of character constants to initialize numeric types and vice versa.

For example, DATA I/'F'/, CHRVAR/65/, J/4HABCD/ is disallowed by -fno-ugly-init.

See Ugly Conversion of Initializers, for more information.

-fugly-logint

Treat INTEGER and LOGICAL variables and expressions as potential stand-ins for each other.

For example, automatic conversion between INTEGER and LOGICAL is enabled, for many contexts, via this option.

See Ugly Integer Conversions, for more information.

-fonetrip

Executable iterative DO loops are to be executed at least once each time they are reached.

ANSI FORTRAN 77 and more recent versions of the Fortran standard specify that the body of an iterative DO loop is not executed if the number of iterations calculated from the parameters of the loop is less than 1. (For example, DO 10 I = 1, 0.) Such a loop is called a zero-trip loop.

Prior to ANSI FORTRAN 77, many compilers implemented DO loops such that the body of a loop would be executed at least once, even if the iteration count was zero. Fortran code written assuming this behavior is said to require one-trip loops. For example, some code written to the FORTRAN 66 standard expects this behavior from its DO loops, although that standard did not specify this behavior.

The -fonetrip option specifies that the source file(s) being compiled require one-trip loops.

This option affects only those loops specified by the (iterative) DO statement and by implied-DO lists in I/O statements. Loops specified by implied-DO lists in DATA and specification (non-executable) statements are not affected.

-ftypeless-boz

Specifies that prefix-radix non-decimal constants, such as Z'ABCD', are typeless instead of INTEGER(KIND=1).

You can test for yourself whether a particular compiler treats the prefix form as INTEGER(KIND=1) or typeless by running the following program:

          EQUIVALENCE (I, R)
          R = Z'ABCD1234'
          J = Z'ABCD1234'
          IF (J .EQ. I) PRINT *, 'Prefix form is TYPELESS'
          IF (J .NE. I) PRINT *, 'Prefix form is INTEGER'
          END
          

Reports indicate that many compilers process this form as INTEGER(KIND=1), though a few as typeless, and at least one based on a command-line option specifying some kind of compatibility.

-fintrin-case-initcap

-fintrin-case-upper

-fintrin-case-lower

-fintrin-case-any

Specify expected case for intrinsic names. -fintrin-case-lower is the default.

-fmatch-case-initcap

-fmatch-case-upper

-fmatch-case-lower

-fmatch-case-any

Specify expected case for keywords. -fmatch-case-lower is the default.

-fsource-case-upper

-fsource-case-lower

-fsource-case-preserve

Specify whether source text other than character and Hollerith constants is to be translated to uppercase, to lowercase, or preserved as is. -fsource-case-lower is the default.

-fsymbol-case-initcap

-fsymbol-case-upper

-fsymbol-case-lower

-fsymbol-case-any

Specify valid cases for user-defined symbol names. -fsymbol-case-any is the default.

-fcase-strict-upper

Same as -fintrin-case-upper -fmatch-case-upper -fsource-case-preserve -fsymbol-case-upper. (Requires all pertinent source to be in uppercase.)

-fcase-strict-lower

Same as -fintrin-case-lower -fmatch-case-lower -fsource-case-preserve -fsymbol-case-lower. (Requires all pertinent source to be in lowercase.)

-fcase-initcap

Same as -fintrin-case-initcap -fmatch-case-initcap -fsource-case-preserve -fsymbol-case-initcap. (Requires all pertinent source to be in initial capitals, as in Print *,SqRt(Value).)

-fcase-upper

Same as -fintrin-case-any -fmatch-case-any -fsource-case-upper -fsymbol-case-any. (Maps all pertinent source to uppercase.)

-fcase-lower

Same as -fintrin-case-any -fmatch-case-any -fsource-case-lower -fsymbol-case-any. (Maps all pertinent source to lowercase.)

-fcase-preserve

Same as -fintrin-case-any -fmatch-case-any -fsource-case-preserve -fsymbol-case-any. (Preserves all case in user-defined symbols, while allowing any-case matching of intrinsics and keywords. For example, call Foo(i,I) would pass two different variables named i and I to a procedure named Foo.)

-fbadu77-intrinsics-delete

-fbadu77-intrinsics-hide

-fbadu77-intrinsics-disable

-fbadu77-intrinsics-enable

Specify status of UNIX intrinsics having inappropriate forms. -fbadu77-intrinsics-enable is the default. See Intrinsic Groups.

-ff2c-intrinsics-delete

-ff2c-intrinsics-hide

-ff2c-intrinsics-disable

-ff2c-intrinsics-enable

Specify status of f2c-specific intrinsics. -ff2c-intrinsics-enable is the default. See Intrinsic Groups.

-ff90-intrinsics-delete

-ff90-intrinsics-hide

-ff90-intrinsics-disable

-ff90-intrinsics-enable

Specify status of F90-specific intrinsics. -ff90-intrinsics-enable is the default. See Intrinsic Groups.

-fgnu-intrinsics-delete

-fgnu-intrinsics-hide

-fgnu-intrinsics-disable

-fgnu-intrinsics-enable

Specify status of Digital's COMPLEX-related intrinsics. -fgnu-intrinsics-enable is the default. See Intrinsic Groups.

-fmil-intrinsics-delete

-fmil-intrinsics-hide

-fmil-intrinsics-disable

-fmil-intrinsics-enable

Specify status of MIL-STD-1753-specific intrinsics. -fmil-intrinsics-enable is the default. See Intrinsic Groups.

-funix-intrinsics-delete

-funix-intrinsics-hide

-funix-intrinsics-disable

-funix-intrinsics-enable

Specify status of UNIX intrinsics. -funix-intrinsics-enable is the default. See Intrinsic Groups.

-fvxt-intrinsics-delete

-fvxt-intrinsics-hide

-fvxt-intrinsics-disable

-fvxt-intrinsics-enable

Specify status of VXT intrinsics. -fvxt-intrinsics-enable is the default. See Intrinsic Groups.

-ffixed-line-length-n

Set column after which characters are ignored in typical fixed-form lines in the source file, and through which spaces are assumed (as if padded to that length) after the ends of short fixed-form lines.

Popular values for n include 72 (the standard and the default), 80 (card image), and 132 (corresponds to "extended-source" options in some popular compilers). n may be none, meaning that the entire line is meaningful and that continued character constants never have implicit spaces appended to them to fill out the line. -ffixed-line-length-0 means the same thing as -ffixed-line-length-none.

See Source Form, for more information.