9.8 Pedantic Compilation

The -fpedantic command-line option specifies that g77 is to warn about code that is not standard-conforming. This is useful for finding some extensions g77 accepts that other compilers might not accept. (Note that the -pedantic and -pedantic-errors options always imply -fpedantic.)

With -fno-f90 in force, ANSI FORTRAN 77 is used as the standard for conforming code. With -ff90 in force, Fortran 90 is used.

The constructs for which g77 issues diagnostics when -fpedantic and -fno-f90 are in force are:

• Automatic arrays, as in

            SUBROUTINE X(N)
            REAL A(N)
            ...
       

  where `A' is not listed in any ENTRY statement, and thus is not a dummy argument.

• The commas in `READ (5), I' and `WRITE (10), J'.

  These commas are disallowed by FORTRAN 77, but, while strictly superfluous, are syntactically elegant, especially given that commas are required in statements such as `READ 99, I' and `PRINT *, J'. Many compilers permit the superfluous commas for this reason.

• DOUBLE COMPLEX, either explicitly or implicitly.

  An explicit use of this type is via a DOUBLE COMPLEX or IMPLICIT DOUBLE COMPLEX statement, for examples.

  An example of an implicit use is the expression `C*D', where `C' is COMPLEX(KIND=1) and `D' is DOUBLE PRECISION. This expression is prohibited by ANSI FORTRAN 77 because the rules of promotion would suggest that it produce a DOUBLE COMPLEX result—a type not provided for by that standard.

• Automatic conversion of numeric expressions to INTEGER(KIND=1) in contexts such as:
  • Array-reference indexes.
  • Alternate-return values.
  • Computed GOTO.
  • FORMAT run-time expressions (not yet supported).
  • Dimension lists in specification statements.
  • Numbers for I/O statements (such as `READ (UNIT=3.2), I')
  • Sizes of CHARACTER entities in specification statements.
  • Kind types in specification entities (a Fortran 90 feature).
  • Initial, terminal, and incrementation parameters for implied-DO constructs in DATA statements.
• Automatic conversion of LOGICAL expressions to INTEGER in contexts such as arithmetic IF (where COMPLEX expressions are disallowed anyway).
• Zero-size array dimensions, as in:

            INTEGER I(10,20,4:2)
       

• Zero-length CHARACTER entities, as in:

            PRINT *, ''
       

• Substring operators applied to character constants and named constants, as in:

            PRINT *, 'hello'(3:5)
       

• Null arguments passed to statement function, as in:

            PRINT *, FOO(,3)
       

• Disagreement among program units regarding whether a given COMMON area is SAVEd (for targets where program units in a single source file are “glued” together as they typically are for UNIX development environments).
• Disagreement among program units regarding the size of a named COMMON block.
• Specification statements following first DATA statement.

  (In the GNU Fortran language, `DATA I/1/' may be followed by `INTEGER J', but not `INTEGER I'. The -fpedantic option disallows both of these.)

• Semicolon as statement separator, as in:

            CALL FOO; CALL BAR
       

• Use of `&' in column 1 of fixed-form source (to indicate continuation).
• Use of CHARACTER constants to initialize numeric entities, and vice versa.
• Expressions having two arithmetic operators in a row, such as `X*-Y'.

If -fpedantic is specified along with -ff90, the following constructs result in diagnostics:

• Use of semicolon as a statement separator on a line that has an INCLUDE directive.