Interface blocks

The interface block allows you to specify an explicit interface for external and dummy procedures. You can also use an interface block to define generic identifiers. An interface body in an interface block contains the explicit specific interface for an existing external procedure or dummy procedure. You can also specify the interface for a procedure using a procedure statement.

>>-INTERFACE_statement-----------------------------------------><

   .-------------------------------.   
   V                               |   
>>---+---------------------------+-+---------------------------><
     +-FUNCTION_interface_body---+     
     +-SUBROUTINE_interface_body-+     
     '-PROCEDURE_statement-------'     

>>-END_INTERFACE_statement-------------------------------------><

INTERFACE_statement

See INTERFACE for syntax details

END_INTERFACE_statement

See END INTERFACE for syntax details

PROCEDURE_statement

See PROCEDURE for syntax details

FUNCTION_interface_body

>>-FUNCTION_statement------------------------------------------><

>>-+--------------------+--------------------------------------><
   '-specification_part-'   

>>-end_function_statement--------------------------------------><

SUBROUTINE_interface_body

>>-SUBROUTINE_statement----------------------------------------><

>>-+--------------------+--------------------------------------><
   '-specification_part-'   

>>-end_subroutine_statement------------------------------------><

FUNCTION_statement, SUBROUTINE_statement

For syntax details, see FUNCTION and SUBROUTINE.

specification_part

is a sequence of statements from the statement groups numbered  2 ,  3  and  5  in Order of statements and execution sequence.

end_function_statement, end_subroutine_statement

For syntax details of both statements, see END.

An interface body cannot contain ENTRY statements, DATA statements, FORMAT statements, statement function statements, or executable statements. You can specify an entry interface by using the entry name as the procedure name in an interface body.

An interface body does not access named entities by host association unless you specify the IMPORT statement. It is treated as if it had a host with the default implicit rules. See Determining Type for a discussion of the implicit rules.

An interface block can be abstract, generic or specific. A generic interface block must specify a generic specification in the INTERFACE statement, while an abstract or specific interface block must not specify such a generic specification. See INTERFACE for details.

The interface bodies within an abstract or specific interface block can contain interfaces for both subroutines and functions.

A generic name specifies a single name to reference all of the procedures in the interface block. At most, one specific procedure is invoked each time there is a procedure reference with a generic name.

The PROCEDURE statement is allowed only if the interface block has a generic specification and is contained in a scoping unit where each procedure name is accessible.

A procedure name used in a PROCEDURE statement must not have been previously specified in any MODULE PROCEDURE statement in any accessible interface block with the same generic identifier.

For an interface to a non-Fortran subprogram, the dummy argument list in the FUNCTION or SUBROUTINE statement can explicitly specify the passing method. See Dummy arguments for details.

MODULE M
 CONTAINS
 SUBROUTINE S1(IARG)
   IARG = 1
 END SUBROUTINE S1
 SUBROUTINE S2(RARG)
   RARG = 1.1
 END SUBROUTINE S2
 SUBROUTINE S3(LARG)
   LOGICAL LARG
   LARG = .TRUE.
 END SUBROUTINE S3
END

USE M
INTERFACE SS
  SUBROUTINE SS1(IARG,JARG)
  END SUBROUTINE
  MODULE PROCEDURE S1,S2,S3
END INTERFACE
CALL SS(II)              ! Calls subroutine S1 from M
CALL SS(I,J)             ! Calls subroutine SS1
END

SUBROUTINE SS1(IARG,JARG)
  IARG = 2
  JARG = 3
END SUBROUTINE