A subprogram (which defines a procedure), can be either a
subroutine or a
function; it is said to be an internal subprogram if it is called or invoked from the same
program or subprogram that
contains it, as follows
program my_program ! declarations ! executable statements, ! among which an invocation to ! internal procedure(s), call my_sub(arg1,arg2,...) fx = my_fun(xx1,xx2,...) contains subroutine my_sub(a1,a2,...) ! declarations ! executable statements end subroutine my_sub function my_fun(x1,x2,...) result(f) ! declarations ! executable statements end function my_fun end program my_program
In this case the compiler will know all about any internal procedure, since it treats the program unit as a whole. In particular, it will "see" the procedure's
interface, that is
f(in the case of a
Being the interface known, the compiler can check whether the actual arguments (
fx, ...) passed to the procedure match with the dummy arguments (
In this case we say that the interface is explicit.
A subprogram is said to be module subprogram when it is invoked by a statement in the containing module itself,
module my_mod ! declarations contains subroutine my_mod_sub(b1,b2,...) ! declarations ! executable statements r = my_mod_fun(b1,b2,...) end subroutine my_sub function my_mod_fun(y1,y2,...) result(g) ! declarations ! executable statements end function my_fun end module my_mod
or by a statement in another program unit that
uses that module,
program my_prog use my_mod call my_mod_sub(...) end program my_prog
As in the preceding situation, the compiler will know everything about the subprogram and, therefore, we say that the interface is explicit.
A subprogram is said to be external when it is not contained in the main program, nor in a module or antoher subprogram. In particular it can be defined by means of a programming language other than Fortran.
When an external subprogram is invoked, the compiler cannot access to its code, so all the information allowable to the compiler is implicitly contained in the calling statement of the calling program and in the type an properties of the acutal arguments, not the dummy arguments (whose declaration is unknown to the compiler). In this case we say that the interface is implicit.
external statement can be used to specify that a procedure's name is relative to an external procedure,
but even so, the interface remain implicit.
interface block can be used to specify the interface of an external procedure,
interface interface_body end interface
interface_body is normally an exact copy of the procedure header followed by the declaration of all its arguments and, if it is a function, of the result.
For example, for function
real function WindSpeed(u, v) real, intent(in) :: u, v WindSpeed = sqrt(u*u + v*v) end function WindSpeed
You can write the following interface
interface real function WindSpeed(u, v) real, intent(in) :: u, v end function WindSpeed end interface