Fortran
Interfaces explícitas e implícitas

Subprogramas internos / módulos e interfaces explícitas

Un subprograma (que define un procedimiento ), puede ser una subroutine o una function ; se dice que es un subprograma interno si se llama o se invoca desde el mismo program o subprograma que lo contains , como sigue

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

En este caso, el compilador sabrá todo sobre cualquier procedimiento interno, ya que trata la unidad del programa como un todo. En particular, "verá" la interface del procedimiento, es decir,

• si es una function o subroutine ,
• cuáles son los nombres y propiedades de los argumentos a1 , a2 , x1 , x2 , ...,
• cuáles son las propiedades del resultado f (en el caso de una function ).

Al conocerse la interfaz, el compilador puede verificar si los argumentos reales ( arg1 , arg2 , xx1 , xx2 , fx , ...) pasaron al procedimiento con los argumentos ficticios ( a1 , a2 , x1 , x2 , f , .. .).

En este caso decimos que la interfaz es explícita .

Se dice que un subprograma es un subprograma de módulo cuando es invocado por una declaración en el módulo que lo contiene,

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

o por una declaración en otra unidad de programa que use s ese módulo,

program my_prog

  use my_mod

  call my_mod_sub(...)

end program my_prog

Como en la situación anterior, el compilador sabrá todo sobre el subprograma y, por lo tanto, decimos que la interfaz es explícita .

Subprogramas externos e interfaces implícitas

Se dice que un subprograma es externo cuando no está contenido en el programa principal, ni en un módulo o subprograma adicional. En particular, se puede definir por medio de un lenguaje de programación que no sea Fortran.

Cuando se invoca un subprograma externo, el compilador no puede acceder a su código, por lo que toda la información permitida al compilador está implícitamente contenida en la declaración del programa que llama y en el tipo una propiedad de los argumentos reales, no los argumentos ficticios ( cuya declaración es desconocida para el compilador). En este caso decimos que la interfaz es implícita .

Se puede usar una declaración external para especificar que el nombre de un procedimiento es relativo a un procedimiento externo,

external external_name_list

Pero aun así, la interfaz permanece implícita.

Se puede utilizar un bloque de interface para especificar la interfaz de un procedimiento externo,

interface
  interface_body
end interface

donde interface_body es normalmente una copia exacta del encabezado del procedimiento seguido de la declaración de todos sus argumentos y, si es una función, del resultado.

Por ejemplo, para la función WindSpeed

real function WindSpeed(u, v)
  real, intent(in) :: u, v
  WindSpeed = sqrt(u*u + v*v)
end function WindSpeed

Puedes escribir la siguiente interfaz

interface
  real function WindSpeed(u, v)
    real, intent(in) :: u, v
  end function WindSpeed
end interface