Fortran
Unità di programma e layout di file

Programmi Fortran

Un programma Fortran completo è composto da un numero di unità di programma distinte. Le unità del programma sono:

• programma principale
• funzione o sottoprogramma subroutine
• modulo o sottomodulo
• bloccare l'unità di programma di dati

Il programma principale e alcuni sottoprogrammi di routine (funzione o subroutine) possono essere forniti da una lingua diversa da Fortran. Ad esempio, un programma principale C può chiamare una funzione definita da un sottoprogramma della funzione Fortran, oppure un programma principale Fortran può chiamare una procedura definita da C.

Queste unità del programma Fortran possono essere fornite come file distinti o all'interno di un singolo file.

Ad esempio, potremmo vedere i due file:

prog.f90

program main
  use mod
end program main

mod.f90

module mod
end module mod

E il compilatore (invocato correttamente) sarà in grado di associare il programma principale al modulo.

Il singolo file può contenere molte unità di programma

everything.f90

module mod
end module mod

program prog
  use mod
end program prog

function f()
end function f()

In questo caso, tuttavia, si deve notare che la funzione f è ancora una funzione esterna per quanto riguarda il programma principale e il modulo. Il modulo sarà accessibile dal programma principale, tuttavia.

Le regole dell'ambito di digitazione si applicano a ogni singola unità di programma e non al file in cui sono contenute. Ad esempio, se vogliamo che ogni unità di scoping non abbia una digitazione implicita, il file sopra riportato deve essere scritto come

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

Moduli e sottomoduli

I moduli sono documentati altrove .

I compilatori spesso generano i cosiddetti file di modulo : di solito il file che contiene

module my_module
end module

risulterà in un file chiamato qualcosa come my_module.mod dal compilatore. In tali casi, affinché un modulo sia accessibile da un'unità di programma, quel file di modulo deve essere visibile prima che quest'ultima unità di programma venga elaborata.

Procedure esterne

Una procedura esterna è quella che è definita al di fuori di un'altra unità di programma o con un mezzo diverso da Fortran.

La funzione contenuta in un file come

integer function f()
  implicit none
end function f

è una funzione esterna.

Per le procedure esterne, la loro esistenza può essere dichiarata usando un blocco di interfaccia (a una interfaccia esplicita)

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

o da una dichiarazione dichiarazione per dare un'interfaccia implicita

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

o anche

program prog
  implicit none
  integer f
  external f
end program prog

L'attributo external non è necessario:

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

Blocca le unità del programma di dati

Le unità del programma di dati di blocco sono unità di programma che forniscono valori iniziali per oggetti in blocchi comuni. Questi sono deliberatamente lasciati senza documenti qui, e saranno presenti nella documentazione delle caratteristiche storiche di Fortran.

Sottoprogrammi interni

Un'unità di programma che non è un sottoprogramma interno può contenere altre unità di programma, chiamate sottoprogrammi interni .

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

Tale sottoprogramma interno ha una serie di caratteristiche:

• esiste un'associazione host tra entità nel sottoprogramma e il programma esterno
• le regole di digitazione implicite sono ereditate ( implicit none è in vigore in f sopra)
• i sottoprogrammi interni hanno un'interfaccia esplicita disponibile nell'host

Sottoprogrammi di modulo e sottoprogrammi esterni possono avere sottoprogrammi interni come

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

File di codice sorgente

Un file di codice sorgente è un file di testo (generalmente) che deve essere elaborato dal compilatore. Un file di codice sorgente può contenere un massimo di un programma principale e un numero qualsiasi di moduli e sottoprogrammi esterni. Ad esempio, un file di codice sorgente può contenere quanto segue

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

Qui dovremmo ricordare che, anche se i sottoprogrammi esterni sono dati nello stesso file dei moduli e del programma principale, i sottoprogrammi esterni non sono esplicitamente noti da nessun altro componente.

In alternativa, i singoli componenti possono essere distribuiti su più file e anche compilati in momenti diversi. La documentazione del compilatore dovrebbe essere letta su come combinare più file in un singolo programma.

Un singolo file di codice sorgente può contenere codice sorgente in forma fissa o in formato libero: non possono essere mescolati, sebbene più file combinati in fase di compilazione possano avere stili diversi.

Per indicare al compilatore il modulo sorgente ci sono generalmente due opzioni:

• scelta del suffisso del nome file
• uso dei flag del compilatore

Il flag di compilazione per indicare una fonte fissa o di forma libera può essere trovato nella documentazione del compilatore.

I suffissi significativi dei nomi dei file si trovano anche nella documentazione del compilatore, ma come regola generale un file denominato file.f90 viene utilizzato per contenere l'origine in forma libera mentre il file file.f viene utilizzato per contenere l'origine in forma fissa.

L'uso del suffisso .f90 per indicare l'origine in forma libera (che è stata introdotta nello standard Fortran 90) spesso induce il programmatore a utilizzare il suffisso per indicare lo standard di linguaggio a cui il codice sorgente è conforme. Ad esempio, potremmo vedere file con suffissi .f03 o .f08 . Ciò è generalmente da evitare: la maggior parte dei sorgenti di Fortran 2003 è anche compatibile con Fortran 77, Fortran 90/5 e Fortran 2008. Inoltre, molti concorrenti non considerano automaticamente tali suffissi.

I compilatori offrono spesso anche un preprocessore di codice incorporato (generalmente basato su cpp). Ancora una volta, può essere usato un flag in fase di compilazione per indicare che il preprocessore deve essere eseguito prima della compilazione, ma il suffisso del file del codice sorgente può anche indicare tale requisito di pre-elaborazione.

Per i filesystem con distinzione tra maiuscole e minuscole, il file file.F viene spesso considerato come un file sorgente di forma fissa da sottoporre a pre-elaborazione e file.F90 per essere un file di origine in formato libero da sottoporre a pre-elaborazione. Come prima, la documentazione del compilatore dovrebbe essere consultata per tali flag e suffissi di file.