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.