Fortran
Unités de programme et disposition des fichiers

Programmes Fortran

Un programme complet de Fortran est composé d'un certain nombre d'unités de programme distinctes. Les unités de programme sont:

• programme principal
• sous-programme fonction ou sous-programme
• module ou sous-module
• bloc de programme de données

Le programme principal et certains sous-programmes de procédure (fonction ou sous-programme) peuvent être fournis par une langue autre que Fortran. Par exemple, un programme principal C peut appeler une fonction définie par un sous-programme de la fonction Fortran, ou un programme principal Fortran peut appeler une procédure définie par C.

Ces unités de programme Fortran peuvent être des fichiers distincts ou dans un seul fichier.

Par exemple, nous pouvons voir les deux fichiers:

prog.f90

program main
  use mod
end program main

mod.f90

module mod
end module mod

Et le compilateur (invoqué correctement) pourra associer le programme principal au module.

Le fichier unique peut contenir plusieurs unités de programme

tout.f90

module mod
end module mod

program prog
  use mod
end program prog

function f()
end function f()

Dans ce cas, cependant, il faut noter que la fonction f est toujours une fonction externe en ce qui concerne le programme principal et le module. Le module sera cependant accessible par le programme principal.

Les règles de portée de saisie s'appliquent à chaque unité de programme individuelle et non au fichier dans lequel elles sont contenues. Par exemple, si nous voulons que chaque unité de portée n’ait pas de saisie implicite, le fichier ci-dessus doit être écrit en tant que

module mod
  implicit none
end module mod

program prog
  use mod
  implicit none
end program prog

function f()
  implicit none
  <type> f
end function f

Modules et sous-modules

Les modules sont documentés ailleurs .

Les compilateurs génèrent souvent des fichiers appelés modules : généralement le fichier contenant

module my_module
end module

se traduira par un fichier nommé quelque chose comme my_module.mod par le compilateur. Dans de tels cas, pour qu'un module soit accessible par une unité de programme, ce fichier de module doit être visible avant le traitement de cette dernière unité de programme.

Procédures externes

Une procédure externe est une procédure définie à l'extérieur d'une autre unité de programme ou par un autre moyen que Fortran.

La fonction contenue dans un fichier comme

integer function f()
  implicit none
end function f

est une fonction externe.

Pour les procédures externes, leur existence peut être déclarée en utilisant un bloc d'interface (pour donner une interface explicite)

program prog
  implicit none
  interface
    integer function f()
  end interface
end program prog

ou par une déclaration pour donner une interface implicite

program prog
  implicit none
  integer, external :: f
end program prog

ou même

program prog
  implicit none
  integer f
  external f
end program prog

L'attribut external n'est pas nécessaire:

program prog
  implicit none
  integer i
  integer f
  i = f()   ! f is now an external function
end program prog

Bloquer les unités de programme de données

Les unités de programme de données en bloc sont des unités de programme qui fournissent des valeurs initiales pour les objets dans les blocs communs. Ceux-ci sont délibérément laissés sans papiers ici, et figureront dans la documentation des fonctionnalités historiques de Fortran.

Sous-programmes internes

Une unité de programme qui n’est pas un sous-programme interne peut contenir d’autres unités de programme, appelées sous-programmes internes .

program prog
  implicit none
contains
  function f()
  end function f
  subroutine g()
  end subroutine g
end program

Un tel sous-programme interne présente plusieurs caractéristiques:

• il y a association d'hôte entre les entités dans le sous-programme et le programme externe
• les règles de typage implicites sont héritées ( implicit none dans f ci-dessus)
• les sous-programmes internes ont une interface explicite disponible dans l'hôte

Les sous-programmes de module et les sous-programmes externes peuvent avoir des sous-programmes internes, tels que

module mod
  implicit none
contains
  function f()
  contains
    subroutine s()
    end subroutine s
  end function f
end module mod

Fichiers de code source

Un fichier de code source est un fichier texte (généralement) à traiter par le compilateur. Un fichier de code source peut contenir jusqu'à un programme principal et un nombre quelconque de modules et de sous-programmes externes. Par exemple, un fichier de code source peut contenir les éléments suivants:

module mod1
end module mod1

module mod2
end module mod2

function func1()    ! An external function
end function func1

subroutine sub1()   ! An external subroutine
end subroutine sub1

program prog        ! The main program starts here...
end program prog    ! ... and ends here

function func2()    ! An external function
end function func2

Rappelons ici que, même si les sous-programmes externes sont donnés dans le même fichier que les modules et le programme principal, les sous-programmes externes ne sont connus explicitement par aucun autre composant.

Les composants individuels peuvent également être répartis sur plusieurs fichiers et même compilés à des moments différents. La documentation du compilateur doit être lue sur la façon de combiner plusieurs fichiers en un seul programme.

Un seul fichier de code source peut contenir un code source de forme fixe ou libre: ils ne peuvent pas être mélangés, bien que plusieurs fichiers combinés au moment de la compilation puissent avoir des styles différents.

Pour indiquer au compilateur la forme source, il existe généralement deux options:

• choix du suffixe du nom de fichier
• utilisation des drapeaux du compilateur

L'indicateur de compilation pour indiquer une source de forme fixe ou libre peut être trouvé dans la documentation du compilateur.

Les suffixes de nom de fichier significatifs se trouvent également dans la documentation du compilateur, mais en règle générale, un fichier nommé file.f90 est considéré comme contenant une source de forme libre, tandis que le fichier file.f contient une source de forme fixe.

L'utilisation du suffixe .f90 pour indiquer la source de forme libre (introduite dans la norme Fortran 90) incite souvent le programmeur à utiliser le suffixe pour indiquer la norme de langue à laquelle le code source est conforme. Par exemple, nous pouvons voir des fichiers avec des suffixes .f03 ou .f08 . Ceci est généralement à éviter: la plupart des sources de Fortran 2003 sont également compatibles avec Fortran 77, Fortran 90/5 et Fortran 2008. De plus, de nombreux comilers ne considèrent pas automatiquement ces suffixes.

Les compilateurs proposent également souvent un préprocesseur de code intégré (généralement basé sur cpp). De nouveau, un indicateur de compilation peut être utilisé pour indiquer que le préprocesseur doit être exécuté avant la compilation, mais le suffixe du fichier de code source peut également indiquer une telle exigence de prétraitement.

Pour les systèmes de fichiers sensibles à la casse, le fichier file.F est souvent considéré comme un fichier source à file.F90 à file.F90 et le file.F90 est un fichier source de forme libre à traiter préalablement. Comme précédemment, la documentation du compilateur doit être consultée pour ces indicateurs et suffixes de fichiers.