Nästa: Grafisk programmeringsmiljö Upp: Användarhandledning för Pascal på Förra: Procedurer och anropsstacken

Modularisering

 Stora program blir ofta mer lättlästa om de delas upp i separata moduler. I ett program som arbetar mycket med vektorer bör till exempel alla procedurer och funktioner för vektorräkning ligga i en egen fil. Riktigt stora program kan bestå av över tio moduler och då är det viktigt att man håller reda på vilka moduler som har behörighet att använda vilka procedurer i vilka andra moduler. Solarispascal är väldigt noga med detta och det finns ett antal reserverade ord för modulariseringen: MODULE, EXTERN, PUBLIC, PRIVATE och include.

För att undvika missförstånd menas med en procedurs deklaration procedurhuvudet som talar om att proceduren existerar. Själva procedurkroppen kallas dess definition.

Det finns tre typer av filer: programfiler, modulfiler och samlingsfiler. Programfilen börjar med ett vanligt programhuvud
PROGRAM programnamn (fillista );
och ser huvudsakligen ut som ett standardprogram. En modulfil kan ha ett modulhuvud, syntaxen är
MODULE modulnamn ;
Modulnamnet behöver inte vara samma som filnamnet, precis som fallet är med programfiler. Resten av modulen ska innehålla deklarationer av variabler och definitioner av procedurer och funktioner. Samlingsfiler kan inte ha något huvud. De innehåller bara deklarationer.

Uppdelning i moduler innebär att man vill definiera procedurer i en annan fil än den de anropas i. Som exempel tar vi följande grisprogram som består av programfilen Gris.p och modulfilen Svin.p.
Källkod till Gris.p:

        PROGRAM Grisljud;
         PROCEDURE Grymta(antal: Integer); EXTERN;
        BEGIN
         Grymta(13);
        END.

Källkod till Svin.p:

        MODULE Knorr;
         PROCEDURE Grymta(antal: Integer);
         BEGIN
          Writeln('Grisen säger NÖFF ',antal:1,' gånger!');
         END;

Proceduren Grymta finns deklarerad i programfilen men definitionen finns i Svin.p. För att tala om att den är definierad i en annan fil skriver man EXTERN efteråt. Programmet skriver bara ut Grisen säger NÖFF 13 gånger! på skärmen. För att kompilera det skriver man

run Gris.p Svin.p
eller
pc -g -C -H -L -tc -o Gris Gris.p Svin.p

Ordningen mellan pascalfilerna som ska kompileras har ingen betydelse, annat än att den i run-kommandot bestämmer vilket namn resultatfilen ska få (resultatfilen namnges efter den första filen).

Variabler kan antingen vara programglobala eller modulglobala. Vi modifierar modulerna ovan så här:
Källkod till Gris.p:

        PROGRAM Grisljud;
         VAR
          i: Integer;
         PROCEDURE Grymta; EXTERN;
        BEGIN
         FOR i := 2 TO 5 DO
          Grymta;
        END.

Källkod till Svin.p:

        MODULE Knorr;
         VAR
          i: Integer;
         PROCEDURE Grymta;
         BEGIN
          Writeln('Grisen säger NÖFF ',i:1,' gånger!');
         END;

Här är variabeln i en och samma variabel i båda modulerna (programglobal). Man får utskriften

        Grisen säger NÖFF 2 gånger!
        Grisen säger NÖFF 3 gånger!
        Grisen säger NÖFF 4 gånger!
        Grisen säger NÖFF 5 gånger!

För att få en variabel modulglobal kan man skriva PRIVATE före VAR. Vi ändrar lite igen:
Källkod till Gris.p:

        PROGRAM Grisljud;
         VAR
          i: Integer;
         PROCEDURE Grymta; EXTERN;
        BEGIN
         FOR i := 2 TO 5 DO
          Grymta;
        END.

Källkod till Svin.p:

        MODULE Knorr;
         PRIVATE VAR
          i: Integer;
         PROCEDURE Grymta;
         BEGIN
          Writeln('Grisen säger NÖFF ',i:1,' gånger!');
         END;

Nu blir utskriften

        Grisen säger NÖFF 0 gånger!
        Grisen säger NÖFF 0 gånger!
        Grisen säger NÖFF 0 gånger!
        Grisen säger NÖFF 0 gånger!

Viktig regel: Alla operationer med variabeln variabel i moduler där variabel är deklarerad programglobalt påverkar samma variabel i samma minnesceller. Operationer med variabel i en modul där variabel är deklarerad modulglobalt däremot, påverkar för andra moduler oåtkomliga minnesceller.

Om man kompilerar ett program med väljaren -xl kommer alla variabler att bli modulglobala om de inte deklarerats med PUBLIC. Utan -xl är det tvärtom, så att variabler blir programglobala om de inte deklarerats med PRIVATE.

Ofta utnyttjar olika moduler samma procedurer och variabler. Det kan då vara trevligt att samla alla deklarationer och definitioner i en särskild samlingsfil. För att en modul ska få tillgång till innehållet i samlingsfilen Samling.h lägger man till raden

#include 'Samling.h'
direkt efter modul-/programhuvudet. Effekten blir att före kompileringen byts #include-raden ut mot innehållet i Samling.h. (Observera att ordet include måste skrivas med gemena bokstäver. Dessutom ska #include stå längst till vänster så man får inte skjuta in några blanka framför.) Eftersom samlingsfil heter header på engelska brukar dessa filer ofta sluta på .h. Man ska inte ta med samlingsfilerna i anropet till kompilatorn.

Nästa: Grafisk programmeringsmiljö Upp: Användarhandledning för Pascal på Förra: Procedurer och anropsstacken