Fortran 77 Notes

This page is a collection of things to watch out when writing Fortran 77 code. These are generally non-standard bits of code which are treated differently by the compilers we have to deal with. Thanks to Clive Page at Leicester for supplying some of these.

• Bit operations. The logical operators .AND. etc. operate in a bitwise manner on BYTE variables in DEC compilers (ie. VMS, Ultrix and OSF). However Sun compilers treat this as logical operation and return 0 or 1. You cannot get around this by casteing the BYTE's to integers and using the IAND etc intrinsic functions portably because the conversion functions are not supported for BYTEs on DEC machines! Putting in multiplication by 1 works but leaves you open to optimiser behaviour. ASTERIX gets around this by providing functions in astlib to support bitwise byte operations portably.

• String concatenation. The Fortran 77 rules for character string concatenation are a bit of a bind. There are essentially two rules to beware of,
  • In any character assignment statement you can't have partial overlap between the characters in the item on the left of the equals sign and any of the items in the expression on the right. The only way around this is to use a extra variable to assign the value to first, then copy it back where you really want it.

  • In a procedure where a dummy argument has its length declared *(*) (which is always the best thing way of declaring dummy args) the argument cannot be used as an argument of the // operator in anything except in an assignment statement.

  The reason for both these rules is that they ensure that avoid the need for temporary storage of unknown length, which simplifies life for the compiler-writer.

• Fortran structures. Despite health warnings in the Starlink programmer guide we find these to be implemented on all the machines we use to a usable standard. There are two things we find poorly implemented, especially on the Solaris compiler.
  • UNION definitions, for which the Solaris Fortran compiler has difficulty generating correct code.

  • "Inline structure declarations". VMS structures allow you structured structure members to be declared in two ways. Either,

    STRUCTURE /PARENT/
      STRUCTURE CHILD(2)
        INTEGER CHILD_VAR
      END STRUCTURE
      INTEGER PARENT_VAR
    END STRUCTURE
    

    or

    STRUCTURE /CHILD/
      INTEGER CHILD_VAR
    END STRUCTURE
    
    STRUCTURE /PARENT/
      RECORD /CHILD/ CHILD(2)
      INTEGER PARENT_VAR
    END STRUCTURE
    

    We have found that only the 2nd version is implemented correctly in the Solaris Fortran compiler (V2.0.1).

  We therefore recommend that you avoid both of these forms.