Appendix 4. Genomgång av hela språket Fortran 90

A 4.0 Inledning
A 4.1 Teckenkombinationer
A 4.2 Datatyper
A 4.3 Deklarationer
A 4.4 Initieringar
A 4.5 Implicita deklarationer
A 4.6 Speciella specifikationer
A 4.7 Allokeringssatser
A 4.8 Tilldelningar
A 4.9 Exekveringskontroll
A 4.10 Programenheter
A 4.11 In- och utmatning

A 4.0 Inledning

Här följer den utlovade systematiska genomgången av hela språket Fortran 90. Den följer vad gäller ordningen Appendix D (syntaxregler) av den formella standarden ISO (1991).

A 4.1 Teckenkombinationer

Vissa grundbegrepp i Fortran skrives med mer än ett skrivtecken.

Upphöjt till markeras med **
Konkatenering, dvs addition av textsträngar, markeras med //

Jämförelse av tal sker med nedanstående alternativa former

        < .LT.                          >   .GT.
        <=  .LE.                        >=  .GE.
        ==  .EQ.                        /=  .NE.

Logisk negering markeras med .NOT.
Logisk skärning markeras med .AND.
Logisk union markeras med .OR.
Logisk ekvivalens markeras med .EQV.
Logisk icke-ekvivalens markeras med .NEQV.

A 4.2 Datatyper

Icke-decimala numeriska konstanter (kan endast användas i DATA-satser).
- Binär konstant B 'binära siffror' eller B "binära siffror"
  Binära siffror 01
- Oktal konstant O 'oktala siffror' eller O "oktala siffror"
  Oktala siffror 01234567
- Hexadecimal konstant Z 'hexadecimala siffror' eller Z "hexadecimala siffror"
  Hexadecimala siffror 0123456789ABCDEF
Exponentbokstav är E och/eller D
Logiska konstanter är .TRUE. och .FALSE.
Access-direktiv är PUBLIC och PRIVATE
Privat-direktiv är PRIVATE och SEQUENCE
Komponent-definition är typ-deklaration (eventuellt med POINTER eller DIMENSION).
Kommandot för en användardefinierad datatyp är
```
        TYPE, access-direktiv :: namn
                privat-direktiv
                komponent-definition
        END TYPE namn
```
Härvid gäller att om privat-direktivet SEQUENCE gäller så måste alla typer i komponent-definitionen också ha den egenskapen. Ett access-direktiv, eller en vanlig PRIVATE sats inne i definitionen, är tillåten endast om typdefinitionen befinner sig i en modul.

A 4.3 Deklarationer

Deklarationer som kan ha KIND-parameter: INTEGER, REAL, CHARACTER, COMPLEX och LOGICAL
Deklaration som dessutom kan ha längd-parameter: CHARACTER.
Längd-parametern kan alternativt ges efter varje element.
Deklaration som har typ-namn: TYPE
Deklaration som inte har något av ovanstående tillägg: DOUBLE PRECISION.
Attribut till ovanstående deklarationer: PARAMETER, PUBLIC eller PRIVATE, ALLOCATABLE, DIMENSION, EXTERNAL, EXTENT, INTENT, INTRINSIC, OPTIONAL, POINTER, SAVE och TARGET.
DIMENSION måste kompletteras med rang och eventuellt även med omfång.
KIND-parametern har formen (KIND=heltalskonstant)
ALLOCATABLE får ej ges för formella argument eller funktionsresultat.
Ett fält specificerat med ALLOCATABLE eller POINTER skall ha getts rang men ej omfång. Ett fält får inte ha båda dessa attribut.
Om POINTER har använts får inte något av TARGET, INTENT, EXTERNAL eller INTRINSIC användas.
Om TARGET har använts får inte något av POINTER, EXTERNAL, INTRINSIC eller PARAMETER användas.
INTENT och OPTIONAL får endast ges vid formella argument.
En variabel kan inte vara PUBLIC om motsvarande typ är PRIVATE
Attributet SAVE får inte ges för element i COMMON-block, för ett formellt argument, för en funktion eller för en subrutin.
En storhet får inte ges både EXTERNAL och INTRINSIC
INTENT ges som INTENT(IN), INTENT(OUT) eller INTENT(INOUT) och innebär att variabeln betecknas som in-variabel, ut-variabel respektive både och.
Explicit dimensionering ges med (undre_gräns : övre_gräns), vid flera dimensioner så många gånger som erfordras, med komma mellan de olika paren, men högsta tillåtna antal dimensioner (rang) är 7. När endast rangen behöver ges utelämnas både undre gräns och övre gräns, dvs bara kolon ges för varje dimension. Om undre gräns är 1 kan undre gräns och : utelämnas. Den "sista" dimensionen kan i ett formellt fält ges med en * i stället för normal specifikation.
INTENT och OPTIONAL kan bara användas i en funktion, subrutin eller INTERFACE specifikation.
SAVE kan följas av variabelnamn och/eller COMMON-namn. Om så ej är fallet sparas allt som kan sparas, och några fler SAVE satser får då ej finnas i den aktuella programenheten.
Om attribut finns med måste deklarationen ges med dubbelkolon, annars kan dubbelkolon utelämnas. Jag rekommenderar att det får vara kvar.

A 4.4 Initieringar

Initieringar kan ske med tilldelning direkt i deklarationen, med DATA-sats, samt permanent med PARAMETER-sats eller PARAMETER-attribut.

    IMPLICIT NONE
    REAL :: A = 1              ! Fortran 90
    REAL B                     ! Fortran 77 och 90
    DATA B / 6 /               ! Fortran 77 och 90
    REAL C                     ! Fortran 77 och 90
    PARAMETER ( C = 12 )       ! Fortran 77 och 90
    REAL, PARAMETER :: D = 17  ! Fortran 90

Varianten med DATA-sats är överlägsen vid initiering av fält, på grund av att man kan använda en upprepningsfaktor. Denna kan faktiskt vara en tidigare definierad heltalskonstant.
```
    REAL, DIMENSION(4) :: A =  (/ 1, 1, 1, 1 /) 
    REAL, DIMENSION(4) :: B 
    DATA B = / 4*1 /
    REAL, DIMENSION(4), PARAMETER :: D =  (/ 1, 1, 1, 1 /) 
```

A 4.5 Implicita deklarationer

Den gamla varianten med implicit typdeklaration, dvs alla variabler som börjar på någon av bokstäverna IJKLMN är heltal INTEGER och alla övriga är flyttal finns fortfarande kvar som skönsvärde. Jag rekommenderar att i stället alltid använda IMPLICIT NONE, för att tvinga fram kompileringsfelutskrift vid alla odeklarerade variabler. Dock finns tyvärr även möjligheten att deklarera att variabler som börjar på viss(a) bokstav skall ha viss typ,
```
        IMPLICIT LOGICAL (B-C, L)
```
Satsen ovan innebär att alla variabler som börjar på någon av bokstäverna B, C eller L betraktas automatiskt som logiska variabler, om de inte explicit (dvs med hela namnet) deklarerats att vara av någon annan typ.
Om IMPLICIT NONE utnyttjas måste den satsen vara först i programenheten (men efter PROGRAM, FUNCTION, SUBROUTINE, BLOCK DATA eller MODULE), och där får då inte finnas några andra IMPLICIT satser.

A 4.6 Speciella specifikationer

Ett nytt kommando är NAMELIST, som tidigare var populärt vid inmatning på IBM:s Fortran-variant. Man utnyttjar därvid såväl gruppnamn inom snedstreck som vanliga variabler.
```
        NAMELIST / list_1 / a, i, x
        NAMELIST / list_2 / b, j, y, / list_3 / c, k, z
```
Som variabelnamn får här inte användas ett formellt fältargument med icke-konstanta gränser, en textsträngsvariabel med variabel längd, en pekare, eller ett allokerbart fält.
Trots att NAMELIST kom med i standarden i och med Fortran 90 är det snarare att betrakta som ett tillägg till Fortran 66 än en verklig beståndsdel av Fortran 90. Det har ej utvidgats till att klara alla nyheter hos datatyperna i Fortran 90.
Om gruppnamnet getts attributet PUBLIC får inte något av variabelnamnen getts attributet PRIVATE.
Ett gammalt kommando är EQUIVALENCE, som utnyttjas för att spara lagringsutrymme. Efter kommandot kommer en uppräkning av de variabler som skall dela lagringsutrymme, varje par ges inom parentes.
```
        REAL, DIMENSION(10) :: C
        INTEGER, DIMENSION(20) :: D
        EQUIVALENCE (A, B), (C(8), D(3))
```
Som variabelnamn får här inte användas ett formellt argument, en pekare, ett allokerbart fält, en funktion, ett ENTRY-namn, ett RESULT-namn, namnet för en konstant, eller en struktur-komponent. Alla variabler som görs ekvivalenta måste vara i samma grupp av datatyper, nämligen i någon av
- Heltal, flyttal, dubbelprecisions-flyttal, komplexa tal samt logiska, samtliga av normalt slag (skönsvärdet).
- Textsträng av normalt slag (skönsvärdet).
- Användardefinierad typ (samma).
- Heltal, flyttal, dubbelprecisions-flyttal, komplexa tal samt logiska eller teststräng, samtliga av annat slag än skönsvärdet. I detta fall kan ekvivalens ske endast mellan variabler av samma typ och samma slag!
Ett gammalt kommando är COMMON, som utnyttjas för att överföra information mellan olika programenheter. Efter kommandot kommer ett eventuellt block-namn inom snedstreck följt av en uppräkning av de variabler som skall delas.
```
   REAL, DIMENSION(10) :: C
   INTEGER, DIMENSION(20) :: D
   COMMON A, B     ! Blankt COMMON
   COMMON / / E, F ! Fortsättning av blankt COMMON
   COMMON / VEKTORER / C, D
```
I motsats till vid EQUIVALENCE får i detta fall ett variabelnamn bara förekomma en gång.
Som variabelnamn får här inte användas ett formellt argument, ett allokerbart fält, en funktion, ett ENTRY-namn eller ett RESULT-namn. Om variabelnamnet svarar mot en användardefinierad typ, måste denna vara sekventiell, dvs ha attributet SEQUENTIAL. Eventuella fältgränser måste vara konstanta.

A 4.7 Allokeringssatser

Med kommandot ALLOCATE tilldelar man lagringsutrymme till ett fält, och med kommandot DEALLOCATE tar man bort det. Båda kommandona kan utnyttja ett status-attribut, STAT=heltalsvariabel. Denna variabel blir noll om operationen lyckas och får ett implementationsbeoroende positivt värde vid misslyckande. Endast fältvariabler som deklarerats som allokerbara eller som pekare kan allokeras. Allokering kan endast ske med exakt den rang (antal dimensioner) som tidigare deklarerats.
```
  REAL, DIMENSION (:,:,:), ALLOCATABLE :: A
  INTEGER :: I_ALLOKERING, I_AV_ALLOKERING
  ...
  ! Här antas värdena på heltalsvariablerna N och M kända
  ALLOCATE ( A(1:10, 7:19, N:M), STAT = I_ALLOKERING)
  ...
  DEALLOCATE (A, STAT = I_AV_ALLOKERING)
```
Med kommandot NULLIFY tar man bort pekar-associering. Efter kommandot ges en parentes med aktuella pekare som skall av-associeras, med komma emellan.

A 4.8 Tilldelningar

Normal tilldelning är variabel = uttryck. Här får som variabel ej användas ett fält med antagen dimension, dvs att den sista dimensioneringsgränsen endast getts som en * i deklarationen.
Pekar-associering sker med pekarobjekt => målobjekt. Här får som målobjekt användas en variabel eller ett uttryck, men pekarobjektet måste ha deklarerats som pekare, dvs ha attributet POINTER. Ett målobjekt, som är en variabel, måste ha något av attributen POINTER eller TARGET, och det måste ha samma typ och mönster som pekarobjektet. Det får inte vara en fältsektion med vektor-index. Om målobjektet däremot är ett uttryck skall det ge en pekare som resultat.
Villkorlig tilldelning erhålles med satsen WHERE eller konstruktionen WHERE. Den enkla satsen ser ut som följer,
```
        WHERE (mask_uttryck) tilldelning
```
där maskuttrycket är ett logiskt villkor för ett fält och tilldelningssatsen innehåller fält med samma mönster. Tilldelning kommer då att ske enbart för element svarande mot sanna positioner i maskuttrycket. Konstruktionen däremot användes dels då olika tilldelningar skall ske vid sant och falskt, dels vid behov av flera tilldelningssatser.
```
        WHERE (mask_uttryck) 
                tilldelningar
        ELSEWHERE
                tilldelningar
        END WHERE
```

A 4.9 Exekveringskontroll

IF

CASE

DO

GO TO

Den klassiska enkla IF-satsen ser ut som följer,
```
        IF (logiskt_uttryck) exekverbar_sats
```
där om det skalära logiska villkoret är sant så utföres den exekverbara satsen, annars fortsätter exekveringen med nästa sats. Den exekverbara satsen får inte vara en ny IF-sats, CASE eller DO-slinga. Den får inte heller vara en END-sats, men väl en STOP-sats eller normal GO TO sats.
Den moderna IF-konstruktionen ser ut som följer,
```
namn:   IF (logiskt_uttryck) THEN
                exekverbara_satser
        ELSE IF (logiskt_uttryck) THEN namn
                exekverbara_satser
        ELSE namn
                exekverbara_satser
        END IF namn
```
där om det första skalära logiska villkoret är sant så utföres de första exekverbara satserna, annars fortsätter exekveringen med eventuell ELSE IF eller ELSE-del. Om namnet (som är frivilligt att ange) användes på alla fyra ställena måste det vara lika, om det ej ges på den första platsen, dvs före kolon skall även kolon utelämnas, och då kan namnet ej heller ges vid något av de andra ställena. Normalt ger man bara namnet på det första och det sista stället (dvs. efter END IF).
Det är tillåtet att sätta in "nästan vad som helst" bland de exekverbara satserna, till exempel en ny IF-konstruktion.
Den gamla aritmetiska IF-satsen ser ut som följer,
```
 IF (aritmetiskt_uttryck) sats_nr_1, sats_nr_2, sats_nr_3 
```
och medför hopp till det första satsnumret om det aritmetiska uttrycket är negativt, till det andra om det är noll, och till det tredje om det är positivt. Det aritmetiska uttrycket får naturligtvis inte vara komplext.
Den nytillkomna CASE-konstruktionen ser ut som följer,
```
namn:   SELECT CASE (skalärt_uttryck)
        CASE (skalärt_värde_1) namn
                exekverbara satser
        CASE (skalärt_värde-2) namn
                exekverbara satser
        ...
        CASE (skalärt_värde-n) namn
                exekverbara satser
        CASE DEFAULT namn
                exekverbara_satser
        END SELECT namn
```
där det skalära uttrycket kan vara heltal, textsträng eller logiskt. Värdena skall naturligtvis vara av samma typ, men de kan vara intervall (två värden skilda av kolon, i extremfall kan det ena av dessa värden utelämnas) och upprepningar (skilda av komma). De får däremot inte vara givna med överlappningar, dvs ett värde får ej tillfredsställa mer än ett CASE. Om värdet inte tillfredsställer något av dem användes CASE DEFAULT om detta finnes, annars fortsätter exekveringen direkt med nästa sats. Om namnet (som är frivilligt att ange) användes på alla ställena måste det vara lika, om det ej ges på den första platsen, dvs före kolon skall även kolon utelämnas, och då kan namnet ej heller ges vid något av de andra ställena.
Värdena skall vara av samma typ och slag, men för textsträngar är olika längd tillåten. Varianten med kolon är inte tillåten vid logiska värden.
Den välkända DO-slingan har kompletterats på ett flertal punkter, och finns nu i fyra varianter. Beträffande namnsättning gäller samma regler som ovan diskuteras för IF och CASE. Den första varianten är en evig slinga.
```
namn:     DO
                exekverbara satser
          END DO namn
```
Denna kan avbrytas med konventionella hoppsatser eller med den nya satsen EXIT namn, vilken ger ett uthopp ur aktuell slinga, eller slingan med angivet namn. En annan ny sats, CYCLE namn, ger på motsvarande sätt en ny iteration av slingan. Dessa båda satser kan naturligtvis även utnyttjas i de följande varianterna.
Den klassiska DO-slingan har följande utseende.
```
      DO snr styrvariabel = start_värde, slut_värde, steg
            exekverbara satser
snr   sista_exekverbara_sats
```
Det bästa valet för sista_exekverbara_sats är satsen CONTINUE, en sats som inte utför något, men kan användes som platsmarkering för hopp hitan och ditan. Markeringen snr står för satsnummer om en till fem siffror. Kapslade slingor är tillåtna, och kan tillåtas sluta på samma sats. Numera rekommenderas dock att låta varje slinga sluta med sin egen CONTINUE sats eller ännu bättre med sin egen END DO enligt nedan. En modernare variant är nämligen
```
namn:  DO styrvariabel = start_värde, slut_värde, steg
          exekverbara satser
       END DO namn
```
Styrvariabeln kan i båda fallen vara heltal eller flyttal. Vi antar först att steget är utelämnat eller positivt. Om det är utelämnat användes steget ett. Det hela fungerar då så att först sätts styrvariabeln till startvärdet. Om detta värde är större än slutvärdet är det hela klart, och exekveringen fortsätter på nästa sats efter slingan. I annat fall utförs de exekverbara satserna med aktuellt värde på styrvariabeln, varefter denna uppräknas med steget och ny test sker.

Den sista varianten är DO WHILE slingan med följande utseende.

namn:     DO WHILE (logiskt_uttryck)
                exekverbara satser
          END DO namn

Följande bör noteras:
- Efter genomgången slinga har styrvariabeln "nästa värde", dvs det första underkända.
- Om en styrvariabel av typ flyttal användes kan avrundningsfelen spela in.
- Om steget är negativt blir det "likadant fast tvärtom".
- Det är faktiskt tillåtet med ett "onödigt" komma efter DO om detta placeras efter eventuellt satsnummer och före styrvariabeln eller mellan DO och WHILE.
Förutom den klassiska hoppsatsen GO TO snr finns ett flertal varianter. Notera först att satsnummer i den gamla fixa formen skrives med siffror i de fem första positionerna av raden för en Fortransats. I den nya formen skriver man satsnumret till vänster och följt av minst en blank före den "riktiga" satsen.
Den styrda hoppsatsen ser ut på följande sätt.
```
 GOTO (snr1, snr2, ... , snrn) , skalärt_heltals_uttryck
```
Här kan ett godtyckligt antal satsnummer finnas inom parentesen. Kommat efter parentesen är faktiskt onödigt. Om det skalära uttrycket blir 1 sker hopp till det första satsnumret snr1, och så vidare.
Den tilldelade hoppsatsen ser ut på följande sätt.
```
 GOTO satsnummervariabel, (snr1, snr2, ... , snrn)
```
Här kan ett godtyckligt antal satsnummer finnas inom parentesen. Kommat före parentesen är faktiskt onödigt även här. Satsnummervariabel är däremot ett helt nytt begrepp. Det liknar heltal men är i själva verket programadresser. Om en satsnummervariabel skall tilldelas ett visst satsnummer kan detta tyvärr inte ske med en vanlig tilldelningssats utan måste ske med den speciella ASSIGN-satsen. Notera att parentesen med de olika möjliga satsnumren helt kan utelämnas, då måste naturligtvis även eventuellt komma före utelämnas. Man får då följande förenklade variant av den tilldelade hoppsatsen.
```
        GOTO satsnummervariabel
```
Den tidigare nämnda ASSIGN-satsen har följande utseende
```
        ASSIGN satsnummer TO satsnummervariabel
```
Satsnummervariabler kan användas dels för dessa tilldelade hoppsatser, dels vid FORMAT i samband med in- och utmatning. Vid användning i aktuell programenhet av deklarationen IMPLICIT NONE skall satsnummervariablerna deklareras som INTEGER, trots att dom egentligen inte är det.
Fortsättningssatsen är mycket enkel och utför inget. Den kan användas för att ge lämpliga punkter i programmet att hoppa till, och för att avsluta DO-slingor. I det senare fallet rekommenderas att varje DO-slinga får sin egen fortsättningssats.
```
snr   CONTINUE
```
Stoppsatsen är mycket enkel. Den stannar exekveringen med ett standardmeddelande, kompletterad med eventuell stopp-kod.
```
        STOP stopp_kod
```
där stopp-koden kan vara en textsträng eller högst fem decimala siffror.
Paussatsen är likaså mycket enkel. Den stannar exekveringen med ett standardmeddelande, kompletterad med eventuell paus-kod. På ett implementationsberoende sätt kan exekveringen återupptas.
```
        PAUSE paus_kod
```
där paus-koden likaså kan vara en textsträng eller högst fem decimala siffror.

A 4.10 Programenheter

De olika programenheterna är huvudprogram, moduler, BLOCK DATA, subrutiner och funktioner.

Ett huvudprogram har följande uppbyggnad.
```
        PROGRAM program_namn
                Specifikationer
                Satsfunktioner
                Exekverbar del
                Interna funktioner och subrutiner
        END PROGRAM program_namn
```
Den första satsen, PROGRAM program_namn, är helt frivillig, om den användes måste program-namnet anges. Den sista satsen kan vara END, END PROGRAM eller den fullständiga END PROGRAM program_namn. Program-namnet i END-satsen måste naturligtvis vara samma som i PROGRAM-satsen.
De exekverbara satserna får inte innehålla någon av satserna RETURN eller ENTRY.
En modul har följande uppbyggnad.
```
        MODULE modul_namn
                Specifikationer
                Modul-subprogram
        END MODULE modul_namn
```
Motsvarande regler gäller för modul-namnet som för program-namnet. Modulen får inte innehålla satsfunktioner, ENTRY eller FORMAT.
En modul användes med något av följande alternativ.
```
        USE modul_namn
        USE modul_namn, byt_namn_lista
        USE modul_namn, ONLY: enbart_lista
```
I det första fallet blir alla offentliga (PUBLIC) storheter i modulen tillgängliga. Här gäller att alternativet byt_namn_lista består av komponenter av följande utseende.
```
        lokalt_namn => verkligt_namn_i_modulen
```
Motsvarande regler gäller för ONLY, även där kan namnbyte ske. Samtliga storheter som anropas måste naturligtvis vara offentliga.
En BLOCK DATA programenhet ser ut på följande sätt.
```
        BLOCK DATA block_data_namn
                Specifikationer
        END BLOCK DATA block_data_namn
```
Motsvarande regler gäller för block-data-namnet som för program-namnet, men något block data namn är ej nödvändigt att ange.
Specifikationerna får innefatta användning av moduler via USE satser, deklarationer av olika typer inklusive användning av IMPLICIT, PARAMETER satser, användardefinierade datatyper, samt följande olika specifikationer: COMMON, DATA, DIMENSION, EQUIVALENCE, INTRINSIC, POINTER, SAVE och TARGET.
Specifikationerna får däremot inte innefatta ALLOCATABLE, EXTERNAL, INTENT, OPTIONAL, PRIVATE eller PUBLIC. Inte heller får något gränssnitt INTERFACE ingå.
Ett gränssnitt INTERFACE ser ut på följande sätt.
```
        INTERFACE
                Specifikations_del
                Modul_procedur
        END INTERFACE
```
I den första satsen, INTERFACE, kan tillägg ske med högst ett av
- namnet på aktuell generisk funktion
- OPERATOR ( )
- ASSIGNMENT (=)
I fallet OPERATOR ovan skall inom parentesen finnas aktuell operator, till exempel +, -, * eller /.
Specifikations_del får inte innehålla någon av ENTRY, DATA, FORMAT och inte heller någon satsfunktion. Den får inte heller referera till en procedur som definieras i den programenhet i vilken gränssnittet ingår. I övrigt ser den ut som
```
        FUNCTION funktions_namn(argument_lista)
                 specifikationer
        END FUNCTION funktions_namn
        SUBROUTINE subrutin_namn(argument_lista)
                   specifikationer
        END FUNCTION subrutin_namn
```
Man kan förenklat säga att ovanstående erhålles då man tar bort "allt väsentligt", dvs den egentliga procedur-kroppen, ur funktionen eller subrutinen.
Modul-proceduren får endast finnas då INTERFACE satsen har något av tilläggen ovan, och den har då utseendet MODULE PROCEDURE namn_lista, där listan innehåller namn på procedurer som är tillgängliga.
En deklaration av externa funktioner och/eller subrutiner ser ut på följande sätt.
```
  EXTERNAL lista_över_externa_funktioner_och_subrutiner
```
Notera att om denna lista upptar ett namn på en i Fortran 90 inbyggd funktion eller subrutin blir motsvarande inbyggda ej längre tillgänglig. Detta kan användas om man av någon anledning vill skriva till exempel sin egen funktion för beräkning av sinus.
En deklaration av inbyggda funktioner och/eller subrutiner ser ut på följande sätt.
```
  INTRINSIC lista_över_inbyggda_funktioner_och_subrutiner
```
Notera att denna senare lista endast får upptaga namn på i Fortran 90 inbyggda funktioner och subrutiner, dvs de i Appendix 5.
Ett funktionsanrop består helt enkelt av funktionsnamnet med de verkliga (aktuella) argumenten inom parentesen. Notera att vid funktionsanrop kan alternativa återhopp ej användas. Om funktionen saknar argument måste en tom parentes användas.
Ett anrop av en subrutin består däremot av CALL följt av rutinnamnet med de verkliga (aktuella) argumenten inom parentesen. Notera att vid subrutinanrop kan alternativa återhopp användas, vilket sker med en asterisk * följt av satsnummer. Om subrutinen saknar argument utelämnas parentesen.
I de båda fallen (funktion och subrutiner) kan det verkliga argumentet normalt ges antingen enbart på sin korrekta plats jämfört med det formella, eller utnyttjande det formella argumentet som nyckelord, dvs
```
        formellt_argument = verkligt_argument
```
Notera att det formella argument som skall ges som nyckelord måste vara det i gränssnittet, och inte nödvändigtvis det i den verkliga funktionen eller subrutinen. Detta innebär även att ett explicit INTERFACE är en förutsättning för att nyckelord skall kunna användas. Så fort som ett argument getts med nyckelord måste alla följande också ges med nyckelord. De som ges med nyckelord kan ges i godtycklig ordning.
Som argument kan användas även namn på funktioner och subrutiner, men här gäller följande undantag: Man kan som argument inte använda satsfunktioner, interna funktioner, interna subrutiner eller det generiska namnet för en funktion eller subrutin. Observera här särskilt att de specifika och ej de generiska namnen på de inbyggda funktionerna måste användas i detta sammanhang.
En funktion har nedanstående utseende.
```
FUNCTION prefix funktions_namn(argument_lista) RESULT (resultat)
                specifikationer
                satsfunktioner
                exekverbara_satser
                interna_funktioner_och_subrutiner
END FUNCTION funktions_namn
```
De båda delarna prefix och RESULT (resultat) är ej nödvändiga. För prefix gäller att det kan inledas med ordet RECURSIVE och följas av typdeklaration, eller tvärtom.
För RESULT (resultat) gäller att om det ges så skall ej någon typdeklaration ges i prefix och funktionsnamnet får ej typdeklareras på annat sätt i funktionen. Namnet resultat får ej vara samma som funktions_namn.
Ordet FUNCTION måste vara med vid END vad avser en intern funktion eller en modul-funktion. En intern funktion får inte innehålla en ENTRY sats eller i sin tur en intern funktion eller subrutin.
En subrutin har nedanstående utseende.
```
SUBROUTINE subrutin_namn(argument_lista)
           specifikationer
           satsfunktioner
           exekverbara_satser
          interna_funktioner_och_subrutiner
END SUBROUTINE subrutin_namn
```
Första raden kan kompletteras med ordet RECURSIVE före rutin-namnet. Argumentlistan kan innehålla en asterisk * i stället för verkligt argument, nämligen när den ålderdomliga varianten med alternativa återhopp utnyttjas. Argumentlistan kan också helt utgå, nämligen om inga argument finns.
Ordet SUBROUTINE måste vara med vid END vad avser en intern subrutin eller en modul-subrutin. En intern subrutin får inte innehålla en ENTRY sats eller i sin tur en intern funktion eller subrutin.
En ENTRY sats har nedanstående utseende.
```
 ENTRY alternativ_namn(argument_lista) RESULT (resultat)
```
För RESULT (resultat) gäller att om det ges så skall funktionsnamnet ej typdeklareras på annat sätt i funktionen. Namnet resultat får ej vara samma som det på den alternativa ingången alternativ_namn. Inom programenheten får inte alternativ-namn förekomma som formellt argument eller i en annan ENTRY sats eller i en EXTERNAL eller INTRINSIC sats.
En RETURN sats ger återhopp till anropande rutin. Vid alternativa återhopp användes i stället RETURN heltalsuttryck, och ger då återhopp till den alternativa återhoppspunkten placerad i motsvarande position i anropslistan. RETURN är ej tillåtet i huvudprogrammet. Om det saknas ger END normal återhoppsoperation i funktion och subrutin.
En satsfunktion placeras mellan specifikationer och vanliga exekverbara satser i en programenhet och har följande mycket enkla utseende. Satsfunktionerna är enbart tillgängliga i denna programenhet, och ej från andra programenheter.
```
  satsfunktion(argument_lista) = skalärt_uttryck
```
Det skalära uttrycket får använda sig av tidigare (ovanför) definierade satsfunktioner. Rekursiv användning (att den anropar sig själv) är ej tillåten
En CONTAINS sats inleder den eventuella del av en programenhet som innehåller interna funktioner och subrutiner, dvs sådana som enbart är tillgängliga i denna, och ej från andra programenheter. Dessa interna funktioner och subrutiner skrives som vanligt, enda undantaget är att variabler från programenheten (delen över CONTAINS) är tillgängliga utan att deklareras. Ett eventuellt IMPLICIT NONE skall ej upprepas.

A 4.11 In- och utmatning

En fullständig diskussion gavs i kapitel 7 och upprepas därför ej här. Se även diskussionen av FORMAT-bokstäverna i Appendix 2.

Senast modifierad: 27 november 2000
boein@nsc.liu.se