Fortran
Programma-eenheden en bestandsindeling

Fortran-programma's

Een compleet Fortran-programma bestaat uit een aantal afzonderlijke programma-eenheden. Programma-eenheden zijn:

• hoofdprogramma
• functie of subroutine subprogramma
• module of submodule
• blok dataprogramma-eenheid

Het hoofdprogramma en sommige procedure (functie of subroutine) subprogramma's kunnen worden geleverd door een andere taal dan Fortran. Een C-hoofdprogramma kan bijvoorbeeld een functie oproepen die is gedefinieerd door een Fortran-functie-subprogramma, of een Fortran-hoofdprogramma kan een procedure oproepen die is gedefinieerd door C.

Deze Fortran-programma-eenheden kunnen worden gegeven als afzonderlijke bestanden of binnen een enkel bestand.

We kunnen bijvoorbeeld de twee bestanden zien:

prog.f90

program main
  use mod
end program main

mod.f90

module mod
end module mod

En de compiler (correct aangeroepen) kan het hoofdprogramma aan de module koppelen.

Het enkele bestand kan veel programma-eenheden bevatten

everything.f90

module mod
end module mod

program prog
  use mod
end program prog

function f()
end function f()

In dit geval moet echter worden opgemerkt dat de functie f nog steeds een externe functie is wat het hoofdprogramma en de module betreft. De module zal echter toegankelijk zijn voor het hoofdprogramma.

Typen scoopregels zijn van toepassing op elke afzonderlijke programma-eenheid en niet op het bestand waarin ze zijn opgenomen. Als we bijvoorbeeld willen dat elke scoping-eenheid geen impliciet typen heeft, moet het bovenstaande bestand worden geschreven als

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 en submodules

Modules worden elders gedocumenteerd .

Compilers genereren vaak zogenaamde modulebestanden : meestal het bestand met

module my_module
end module

resulteert in een bestand met de naam my_module.mod door de compiler. In dergelijke gevallen moet, om een module toegankelijk te maken voor een programma-eenheid, dat modulebestand zichtbaar zijn voordat deze laatste programma-eenheid wordt verwerkt.

Externe procedures

Een externe procedure is een procedure die buiten een andere programma-eenheid wordt gedefinieerd of op een andere manier dan Fortran.

De functie in een bestand zoals

integer function f()
  implicit none
end function f

is een externe functie.

Voor externe procedures kan hun bestaan worden verklaard met behulp van een interfaceblok (om een expliciete interface te krijgen)

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

of door een verklaring om een impliciete interface te geven

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

of zelfs

program prog
  implicit none
  integer f
  external f
end program prog

Het external kenmerk is niet nodig:

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

Blok data programma-eenheden

Blokdata-programma-eenheden zijn programma-eenheden die initiële waarden verschaffen voor objecten in gemeenschappelijke blokken. Deze zijn opzettelijk hier ongedocumenteerd gelaten en zullen voorkomen in de documentatie van historische Fortran-functies.

Interne subprogramma's

Een programma-eenheid die geen intern subprogramma is, kan andere programma-eenheden bevatten, interne subprogramma's genoemd .

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

Zo'n intern subprogramma heeft een aantal functies:

• er is gastheerassociatie tussen entiteiten in het subprogramma en het buitenprogramma
• impliciete typeregels zijn geërfd ( implicit none effect in f hierboven)
• interne subprogramma's hebben een expliciete interface beschikbaar in de host

Module subprogramma's en externe subprogramma's kunnen interne subprogramma's hebben, zoals

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

Broncodebestanden

Een broncodebestand is een (meestal) tekstbestand dat door de compiler moet worden verwerkt. Een broncodebestand kan maximaal één hoofdprogramma en een willekeurig aantal modules en externe subprogramma's bevatten. Een broncodebestand kan bijvoorbeeld het volgende bevatten

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

We moeten eraan herinneren dat, hoewel de externe subprogramma's in hetzelfde bestand staan als de modules en het hoofdprogramma, de externe subprogramma's niet expliciet bekend zijn bij een andere component.

Als alternatief kunnen de afzonderlijke componenten over meerdere bestanden worden verspreid en zelfs op verschillende tijdstippen worden gecompileerd. De documentatie van de compiler moet worden gelezen over het combineren van meerdere bestanden in een enkel programma.

Een enkel broncodebestand kan broncode in vaste vorm of in vrije vorm bevatten: ze kunnen niet worden gemengd, hoewel meerdere bestanden die tijdens het compileren worden gecombineerd, verschillende stijlen kunnen hebben.

Om aan de compiler het bronformulier aan te geven, zijn er over het algemeen twee opties:

• keuze van het achtervoegsel van de bestandsnaam
• gebruik van compilervlaggen

De compilatie-vlag om de bron in vaste of vrije vorm aan te geven, is te vinden in de documentatie van de compiler.

De belangrijke achtervoegsels voor bestandsnamen zijn ook te vinden in de documentatie van de compiler, maar als algemene regel wordt aangenomen dat een bestand met de naam file.f90 een bron met vrije vorm bevat, terwijl het bestand file.f een bron met vaste vorm bevat.

Het gebruik van het .f90 achtervoegsel om de bron van de vrije vorm aan te geven (die werd geïntroduceerd in de Fortran 90-standaard) verleidt de programmeur vaak om het achtervoegsel te gebruiken om de taalstandaard aan te geven waaraan de broncode voldoet. We kunnen bijvoorbeeld bestanden met de .f03 of .f08 . Dit moet in het algemeen worden vermeden: de meeste Fortran 2003-bronnen voldoen ook aan Fortran 77, Fortran 90/5 en Fortran 2008. Veel comilers overwegen dergelijke achtervoegsels niet automatisch.

Compilers bieden vaak ook een ingebouwde code-preprocessor (meestal gebaseerd op cpp). Wederom kan een compilatietijdvlag worden gebruikt om aan te geven dat de preprocessor vóór compilatie moet worden uitgevoerd, maar het achtervoegsel van het broncodebestand kan ook een dergelijke vereiste van voorbewerking aangeven.

Voor hoofdlettergevoelige bestandssystemen wordt het bestand file.F vaak beschouwd als een vast file.F90 dat moet worden voorverwerkt en file.F90 als een vrij file.F90 dat moet worden voorverwerkt. Zoals eerder, moet de documentatie van de compiler worden geraadpleegd voor dergelijke vlaggen en bestandssuffixen.