Plugins - Pascal. Brugerdefinerede moduler i pascal Arbejde med standardmoduler i pascal-eksempler
Moduler i Pascal i forhold til hoveddelen af programmet ligner de subrutiner (procedurer og funktioner). Men per definition er de uafhængige programmer, hvis ressourcer kan bruges i andre programmer. Derudover er modulerne beskrevet uden for den kaldende applikation, men i en separat fil, så et modul er et separat kompileret program. Den kompilerede modulfil (dette er præcis, hvad der kræves til brug) vil have den udvidelse, der leveres af programmeringsmiljøet (f.eks. .tpu, .ppu, .pcu).
Moduler skabes som regel for at sikre kodekompakthed, hvilket store projekter skal bekymre sig om. Det er også værd at bemærke, at brugen af moduler på en måde fjerner begrænsningen på hukommelsessegmentering, da koden for hvert modul er placeret i et separat segment.
Modulstrukturen ser således ud:
Enhed<имя модуля>;
Interface
<интерфейсная часть>
Implementering
<исполняемая часть>
Begynde
<инициализация>
Ende.
Enhedens navn
Modulnavn efter nøgleordet Enhed, skal svare til navnet på filen (uden .pas), hvori dens kode er placeret. Ved at bruge navnet forbindes modulet også til et andet modul eller til hovedprogrammet. For at gøre dette skal du angive et serviceord Bruger, og angiv listen over plug-ins adskilt af kommaer:
Bruger<список имен модулей>;
Interface del
Interfacedelen beskriver overskrifterne på objekter, som andre moduler og programmer vil have adgang til. Disse er konstanter, typer, variabler og subrutiner. For eksempel er det sådan, grænsefladedelen af søgemodulet kan se ud, som indeholder algoritmer til at søge efter elementer i et array.
|
1 |
enhed Søgning; |
For at erklære dette modul skal du angive dets navn i programmet:
Hvorefter det vil være muligt at bruge alle de objekter, der er beskrevet i grænsefladedelen.
Implementering
Dette afsnit begynder med ordet Implementering(implementering). Det er her, du skal beskrive de underrutiner, der er deklareret i interfacedelen. Samtidig er det tilladt ikke at angive formelle parametre i deres overskrifter, ellers skal de falde fuldstændig sammen med dem i grænsefladedelen. Derudover kan grænsefladedelen indeholde objekter, der er lokale (utilgængelige for det kaldende program) for modulet.
Indledende del
Den initierende del begynder sit arbejde, før udførelsen af hovedprogrammet begynder. Den (mellem Begin og Slut) beskriver som regel operatører beregnet til forskellige former for hjælpearbejde. Denne del kan mangle eller har muligvis ingen kode. I det første tilfælde skal du angive End med en prik, i det andet skal du efterlade et tomt rum inde i Start og End.
Kompilering af moduler
Du kan kun bruge kompilerede moduler i programmet, som har den udvidelse, der leveres af dit applikationsudviklingsmiljø. Lad os se på de tre mest populære af dem:
Turbo Pascal
Resultatet af at kompilere modulet i Turbo Pascal vil være en fil med filtypenavnet .tpu (Turbo Pascal enhed), gemmer dens kode.
Gratis Pascal
Efter kompilering af modulet i Free Pascal oprettes to filer med forskellige opløsninger: .ppu Og .o. Den første indeholder grænsefladedelen af modulet, og den anden (nødvendig for at sammensætte programmet) indeholder en del af implementeringerne.
Pascal ABC.NET
Pascal ABC.Net genererer ikke maskinsprogkode under modulkompilering. Hvis kompileringen lykkes, gemmes koden i en fil med tilladelse .pcu.
Der er tre kompileringstilstande til programmeringsmiljøerne Turbo Pascal og Free Pascal: Kompiler, lav og byg. I kompileringstilstand skal alle moduler, der bruges i programmet, være kompileret på forhånd. Applikationen i Make compilation-tilstand kontrollerer alle tilsluttede moduler for tilstedeværelsen af filer med den passende opløsning til programmeringsmiljøet (.tpu eller .o). Hvis nogen af dem ikke findes, søges der i en fil med navnet på det ufundne modul og filtypen .pas. Den mest pålidelige tilstand er Byg. Søgning og kompilering af filer (med filtypenavnet .pas) i denne tilstand sker, selv når der allerede findes modulære filer.
Eksempel
Lad os lave et lille modul, der indeholder procedurer til binær og lineær søgning af elementer i et array. Modulkode:
|
1 |
enhed Søgning; |
Al denne kode skal være i en separat fil. Lad os nu skrive hovedprogrammet, som vi vil forbinde vores søgemodul til.
modul
(ENHED-modul, enhed) er en autonomt (separat) kompileret programenhed, der indeholder komponenter i beskrivelsessektionen (etiketter, konstanter, typer, variabler, procedurer, funktioner), og kan også indeholde operatører af initialiseringsdelen.
Modulet i sig selv er ikke et eksekverbart program, men er beregnet til at blive brugt af andre programmer og moduler.
Modulstruktur
Modulet har følgende struktur:
ENHED<
modulnavn >
GRÆNSEFLADE
<
interface sektion >
IMPLEMENTERING
<
implementeringsafsnit >
BEGYNDE
<
initialiseringssektion >
ENDE.
Modul titel består af et reserveret ord Enhed(modul) og modulnavnet.
Navnet på modulet vælges i henhold til de generelle regler og skal svare til navnet på den diskfil, der indeholder modulets kildekode.
Udvidelse i modulnavnet (. pas
) er ikke angivet, den er indstillet som standard.
Modulnavnet bruges til at linke det til hovedprogrammet ved hjælp af en klausul Bruger .
Tilbud Bruger M.B. placeres efter modultitlen eller efter ordene
Interface Og Implementering .
Interface del Interface(grænseflade, artikulation, forbindelse) og indeholder referencer til andre moduler og deklarationer (beskrivelser) af globale objekter, dvs. etiketter, konstanter, typer, variabler og overskrifter for procedurer og funktioner, der er tilgængelige for hovedprogrammet og andre moduler (dvs. synlige udefra).
Implementeringsafsnit – starter med et nøgleord Implementering(udførelse) og indeholder en beskrivelse af objekter lokalt for modulet, det vil sige etiketter, konstanter, typer, variabler, der ikke er tilgængelige for hovedprogrammet og andre moduler (dvs. ikke synlige udefra) og en komplet beskrivelse af procedurer og funktioner. I dette tilfælde er der i subrutinernes overskrift en liste over formelle parametre. udeladt, men hvis det er givet, skal det nøjagtigt svare til beskrivelsen i interfacedelen.
Initialiseringsafsnit
– omgivet af verbale parenteser BEGYND SLUT.
og indeholder sætninger, der vil blive udført, før kontrollen overføres til hovedprogrammet. Dette kan være data (variable) initialiseringsoperatører For eksempel tildelings- og inputoperatører, samt procedurer for sammenkædning og åbning af filer. Operatørsektion m.b. tom BEGYND SLUT eller blot være fraværende ENDE .
Der er en periode i slutningen af modulet.
Kompilering og brug af moduler
Systemets RAM har en segmentstruktur (et segment er lig med 64K = 65535 bytes). Programkode m.b. ikke mere end ét segment, datavolumen må ikke overstige ét segment (medmindre der bruges dynamisk hukommelse) og ét segment til stakken. Stakstørrelsen er fastsat af direktivet ($M<>). Den mindste stakstørrelse er 1K, standard maksimalt ét segment er 16K. Værdierne af lokale variable skubbes ind på stakken, når du kalder en subrutine, og springes fra stakken, når du forlader.
Modulkoden er placeret i et separat segment, fordi det oversættes uafhængigt af hovedprogrammet, og antallet af moduler, der bruges af programmet, afhænger kun af den tilgængelige OP. Dette giver dig mulighed for at oprette store programmer.
Compileren opretter modulkode med samme navn, men med udvidelsen tpu
(turbo pascal enhed).
For at bruge et modul ved hovedprogrammet eller andre moduler, placeres dets navn (uden udvidelse) i sætningslisten Bruger
Hvis modulet er kompakt og ofte m.b. bruges af applikationsprogrammer, kan den placeres i biblioteket af standardmoduler TURBO.TPL (Turbo-Pasacal-bibliotek )
ved hjælp af værktøjet TPUMOVER.
Men dette bør kun gøres i nødstilfælde, fordi... biblioteket indlæses i OP og reducerer pladsen til programmet.
Når du kompilerer en fil med et moduls kildetekst, vises en fil af samme navn med filtypenavnet tpu
og placeres i den mappe, der er angivet af indstillingen
VALGMULIGHEDER/MATERIALER/ENHEDSKAB
eller i den aktuelle mappe, hvis denne mulighed ikke er tilgængelig.
Ved kompilering af hovedprogrammet skal de anvendte moduler være i den mappe, der er angivet af indstillingen
MULIGHEDER/DIRECTORIES/EXE & TPU DIRECTORIES
eller i den aktuelle mappe, hvis denne mulighed mangler
For at få EXE opgavefil i option
SAMLER/DESTINATION/DISK(MEMORI)
installere DISK
.
Der er tre modulkompileringstilstande:
- UDARBEJDE
- BYG
- LAVE
Tilstande indstilles af menuen UDARBEJDE
1. Tilstand UDARBEJDE(hedder Alt-F9
). I dette tilfælde kompileres programmet, og de anvendte moduler skal kompileres. prækompileret og gemt i passende mapper.
2. Mode BYG(hedder -
F9). I dette tilfælde ignoreres tidligere kompilerede moduler, og moduler med udvidelsen søges pas
og er rekompileret.
3. Tilstand LAVE(hedder F9). I dette tilfælde er det kun moduler, der havde ændringer i teksten, der genkompileres.
Eksempel 16.1.
I fil inp.txt der er tre arrays af reelle tal
2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Evaluer funktion
hvor Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc - det maksimale element, sum og antal positive elementer i de tilsvarende arrays a, b og c.
Udskriv resultatet til en fil ud.
txt
og på skærmen.
Modultekst
Enhed UNMAS;
Interface
Konst n=10;
Skriv vec=array af reel;
Var z:vec;
i:heltal;
f1,f2:tekst;
Procedure SK1(z:vec; antal:byte; Var s:real; Var k:byte);
Funktion MAX(z:vec; antal:byte):real;
Implementering
Procedure Vv(s:char; num:byte;Var z:vec);
Begynde
Writeln("Array",s);
For i:=1 til num do
Begynde
Læs(f1,z[i]); Skriv(z[i]:4:1," ":3);
Ende;
Læsln(f1); Skrivln;
Ende;
Procedure SK1(z:vec;num:byte; Var s:real; Var k:byte);
Begynde
s:=0; k:=0;
for i:=1 til num gør hvis z[i]>0 derefter
Begynde
s:=s+z[i];
k:=k+1
Ende;
Ende;
Funktion MAX(z:vec;antal:byte):real;
Var m:real;
Begynde
m:=z;
for i:=1 til num gør hvis z[i]>m så m:=z[i];
MAX:=m
Ende;
Begynde
Tildel(f1,"inp.txt"); Nulstil(f1);
Tildel(f2,"out.txt"); Omskriv(f2)
Ende.
Program tekst
Program lr7_16;
Bruger CRT,UNMAS;
Var
a,b,c:vec;
y,sa,sb,sc:real;
ka,kb,kc:byte;
Begynde
clrscr;
Vv("a",8,a);
Vv("b",9,b);
Vv("c",n,c);
SK1(a,8,sa,ka);
SK1(b,9,sb,kb);
SK1(c,n,sc,kc);
y:=(MAX(a,8)+MAX(b,9)+MAX(c,n))+(sa+sb+sc+ka+kb+kc);
Writeln("Resultat:":20);
Write("Array a:");
Writeln("sa=",sa:5:1," ka=",ka);
Skriv("Array b:");
Writeln("sb=",sb:5:1," kb=",kb);
Skriv("Array c:");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
Læsln;
Writeln(f2,"ђҐ§г"мв в:");
Writeln(f2," ":10,"y=",y:10);
Luk(f1);
Luk (f2)
Ende.
Program resultater
Array a
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Array b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Array c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Resultat:
Array a: sa= 17,6 ka=4
Array b: sb= 15,0 kb=5
Array c: sc= 28,9 kc=5
y = 9,330E+01
Plug-ins.
1. Grundlæggende bestemmelser
Plug-in modul– en fil, der indeholder kildetekst på Pascal-sprog, med en bestemt struktur, beregnet til brug både i hovedprogrammet og i andre plug-ins. Brug er at inkludere et modul i anvendelsessektionen ved at angive dets navn.2. Generel opbygning af plug-in-modulet
Enhed<имя модуля>; Interface Implementering Slut.
Strukturelt kan plug-in-modulet opdeles i tre sektioner: 1) Interface sektion - interface (skal erklæres, kan være tom) 2) Implementering sektion - implementering (skal erklæres, kan være tom) 3) Modul body - start -ende. (mangler muligvis)
2.1. Interface sektion.
Interface sektion– plug-in-område, der starter med grænsefladenøgleordet og slutter med implementeringsnøgleordet, som kan indeholde: - en liste over plugins; - konstanter; - brugerdefinerede datatyper; - variabler; - prototyper af procedurer og funktioner tilgængelige fra dette moduls tilslutningspunkt. Note 1: variabler erklæret i grænsefladesektionen er globale. Det vil sige, at de findes overalt i programmet, hvor dette modul er tilsluttet, inklusive i implementeringsdelen af selve modulet. Note 2: som i programmet kan ovenstående sektioner (erklæringer af konstanter, variabler osv. med undtagelse af anvendelsessektionen) i dette afsnit arrangeres i enhver rækkefølge og i enhver mængde. Note 3: Hvis prototyper af procedurer/funktioner er deklareret i dette afsnit, skal deres implementeringer garanteres at være til stede i implementeringsafsnittet. Hovedformål: definerer offentlige data/funktionalitet til brug fra et program eller modul, der bruger dette modul.Eksempel på en grænsefladesektion:
Interface (plug-ins) Bruger AnotherUnit; (konstanter) Konst PI=3,14159265; E=2,71828182; (brugerdefinerede datatyper) Type TMyType=array[-3..7] af real; (variabler) Var temp:TMyType; (procedurer og funktioner) Procedure Fill(var x:TMyType); Funktion Find(const x:TMyType; const Værdi:real):Boolsk; Implementering
2.2. Implementeringsafsnit.
Implementeringsafsnit– området for plug-in-modulet, startende med nøgleordsimplementeringen og slutter med modulets brødtekst (hvis der er en) eller nøgleordet slutter med en prik, der angiver slutningen af modulet, i hvilke implementeringer af procedurer og funktioner erklæret i grænsefladeafsnittet er placeret, som kan indeholde: - en liste over plug-ins-moduler; - konstanter; - brugerdefinerede datatyper; - variabler; - procedurer og funktioner, der er nødvendige for at implementere de procedurer/funktioner, der er angivet i grænsefladeafsnittet. Hovedformål: implementering af procedurer og funktioner beskrevet i grænsefladeafsnittet. Note 1: Ved implementering af procedurer og funktioner beskrevet i grænsefladeafsnittet kan deres overskrifter beskrives i forkortet form. Undtagelse - PascalABC: når der bruges headervariabler i implementeringsteksten, opstår der en kompileringsfejl.Eksempel 1 (overskrifter i forkortet form):
Unit DemoUnit; Interface (procedure prototype) Procedure Swap(var a,b:heltal); Implementeringsprocedure Swap; Var Temp:heltal; Start Temp:=a; a:=b; b:=Temp; ende; ende.
Eksempel 2 (overskrifter i fuld form):
Unit DemoUnit; interface (funktionsprototype) Funktion GetMax(a,b:heltal):heltal; Implementeringsfunktion GetMax(a,b:heltal):heltal; Begynd Hvis a>b så GetMax:=a Andet GetMax:=b; Ende; Ende.
2.3. Modul krop.
Modul krop– det sidste område af plug-in-modulet, dannet af et par nøgleord: “begynde” og “slut.”, hvori programkoden kan placeres på samme måde som hovedprogrammet. Modulets krop mangler muligvis. I dette tilfælde skrives søgeordet "begynd" ikke, men "slut". signalerer slutningen af modulet. Hovedformål: initialisering af modulvariabler, allokering af ressourcer, der er nødvendige for dets drift osv.Eksempel på et modul, der indeholder en krop:
Unit DemoUnit; Interface Konst N=50; Var Rødder: række af ægte; Implementering bruger matematik; Var I:heltal; (modulets krop) Begynd For i:=1 til N do Roots[i]:=sqrt(i); Ende.
Eksempel på et modul uden brødtekst: (se eksempel på et modul for overskrifter i fuld form).
Note 1: Programkoden, der er placeret i modulets krop, udføres én gang - når modulet er indlæst, før eksekveringen af hovedprogramkoden begynder. Note 2: I det tilfælde, hvor flere moduler, der har initialiseringssektioner, er forbundet i anvendelsessektionen, udføres koden for disse sektioner i den rækkefølge, som modulerne er forbundet.2.4. Yderligere afsnit i modulstrukturen.
Free Pascal, Pascal ABC, Pascal ABC.Net compilere tillader, ud over dem, der er anført ovenfor, yderligere to sektioner: - en initialiseringssektion - en færdiggørelsessektion. 2.4.1. Initialiseringsafsnit. Initialiseringsafsnit– plug-in-området placeret efter afslutningen af implementeringssektionen, startende med initialiseringsnøgleordet og slutter med finaliseringssektionen, hvis der er et, eller slutnøgleordet efterfulgt af en prik. Formålet ligner modulkroppen. 2.4.2. Afslutningsafsnit. Afslutningsafsnit– et plug-in-område placeret i slutningen af initialiseringssektionen, hvis der er en, eller i slutningen af implementeringssektionen, og slutter med slutnøgleordet efterfulgt af en prik. Hovedformål: frigivelse af ressourcer tildelt til moduldrift.
enhed DemoUnit; interface var a:array af ^integer;(array af pointere) implementering (hukommelsesallokering og initialisering med værdier) procedure AllocateArray; var i:heltal; start for i:=1 til 20 skal begynde New(a[i]); a[i]^:=i; ende; ende; (deallokering af hukommelse) procedure DeallocateArray; var i:heltal; start for i:=1 til 20 do Dispose(a[i]); ende; initialisering AllocateArray;(initialisering - start af arbejde - alloker hukommelse) færdiggørelse DeallocateArray;(afslutning - afslutning på arbejde - frigør hukommelse) slut.
Note 1: Programkoden placeret i de anførte sektioner udføres én gang. Koden for initialiseringssektionerne er før starten af udførelse af hovedprogramkoden, koden for afslutningssektionerne er efter. Note 2: Hvis et modul indeholder nogen af disse to sektioner, er tilstedeværelsen af et modullegeme ikke længere tilladt.3. Kompilering af moduler.
Hvert plug-in kompileres separat, og kompileringsresultatet afhænger af den anvendte compiler.
3.1. Kompilering i Turbo Pascal.
Resultatet af at kompilere et plug-in i Turbo Pascal er en *.tpu-fil (Turbo Pascal Compiled Unit), som er en maskinrepræsentation af data og kode, der er placeret i den.
3.2. Kompilere i Free Pascal.
Resultatet af kompilering af et plug-in-modul i Free Pascal er to filer: *.ppu - en fil, der indeholder modulets interface-del, og en *.o-fil - en objektfil, der indeholder en del af implementeringerne. Desuden er sidstnævnte nødvendigt for at sammensætte ansøgningen.
3.3. Kompilering i Pascal ABC.Net.
I modsætning til de ovennævnte miljøer genererer Pascal ABC.Net ikke maskinsprogskode under modulkompilering. Kompileren af dette miljø afslutter sit arbejde efter at have udført en semantisk analyse, og gemmer modulets semantiske træ i et mellemformat - *.pcu - en fil, der til en første tilnærmelse kan betragtes som resultatet af kompilering med de angivne begrænsninger .
3.4. Fremskynder programkompilering.
På applikationsforbindelsesstadiet samler linkeren et eksekverbart modul og tager objektmoduler som input. Når du allerede har kompileret plug-ins, er det hurtigere at kompilere programmer ved hjælp af dem, da de allerede er blevet behandlet. Dette gælder for Turbo og Free Pascal. Men i Pascal ABC.Net opnås kompileringshastighed kun på grund af det faktum, at der ikke er behov for at udføre syntaktisk og semantisk analyse. Konklusion: kompilerede versioner af eksekverbare moduler er ikke kompatible mellem forskellige compilere.
Kode til opgaven: "Plug-ins"
Tekstmæssige
Programoversigt
Enhed u1; interface procedure PrintFirst; procedure PrintFirstSecond; implementering bruger u2; (<--- Раньше было в Interface } procedure PrintFirst; begin writeln("Print first"); end; procedure PrintFirstSecond; begin writeln("Print first"); PrintSecond; end; end.
Moduler i Pascal, i forhold til hoveddelen af programmet, ligner subrutiner (procedurer og funktioner). Men per definition er de uafhængige programmer, hvis ressourcer kan bruges i andre programmer. Derudover er modulerne beskrevet uden for den kaldende applikation, men i en separat fil, så et modul er et separat kompileret program. Den kompilerede modulfil (dette er præcis, hvad der kræves til brug) vil have den udvidelse, der leveres af programmeringsmiljøet (f.eks. .tpu, .ppu, .pcu).
Moduler skabes som regel for at sikre kodekompakthed, hvilket store projekter skal bekymre sig om. Det er også værd at bemærke, at brugen af moduler på en måde fjerner begrænsningen på hukommelsessegmentering, da koden for hvert modul er placeret i et separat segment.
Modulstrukturen ser således ud:
Enhed<имя модуля>; Interface<интерфейсная часть>Implementering<исполняемая часть>Begynde<инициализация>Ende.
Enhedens navn
Modulnavnet efter Unit nøgleordet skal matche navnet på filen (uden .pas), hvori dens kode er placeret. Ved at bruge navnet forbindes modulet også til et andet modul eller til hovedprogrammet. For at gøre dette skal du angive serviceordet Uses og liste listen over plug-ins adskilt af kommaer:
Bruger<список имен модулей>;
Interface del
Interfacedelen beskriver overskrifterne på objekter, som andre moduler og programmer vil have adgang til. Disse er konstanter, typer, variabler og subrutiner. Sådan kan grænsefladedelen af søgemodulet f.eks. se ud, som indeholder algoritmer til at søge efter elementer i et array.
Enhedssøgning; Interface type arr = matrix af heltal; var s: streng; procedure binær_søgning(x: heltal; Ar: arr; var s: streng); procedure line_search(x: heltal; Ar: arr; var s: streng);
For at erklære dette modul skal du angive dets navn i programmet:
Hvorefter det vil være muligt at bruge alle de objekter, der er beskrevet i grænsefladedelen.
Implementering
Dette afsnit begynder med ordet Implementering. Det er her, du skal beskrive de underrutiner, der er erklæret i interfacedelen. Samtidig er det tilladt ikke at angive formelle parametre i deres overskrifter, ellers skal de falde fuldstændig sammen med dem i grænsefladedelen. Derudover kan grænsefladedelen indeholde objekter, der er lokale (utilgængelige for det kaldende program) for modulet.
Indledende del
Den initierende del begynder sit arbejde, før udførelsen af hovedprogrammet begynder. Den (mellem Begin og Slut) beskriver som regel operatører beregnet til forskellige former for hjælpearbejde. Denne del kan mangle eller indeholder muligvis ingen kode. I det første tilfælde skal du angive End med en prik, i det andet skal du efterlade et tomt rum inde i Start og End .
Kompilering af moduler
Du kan kun bruge kompilerede moduler i programmet, som har den udvidelse, der leveres af dit applikationsudviklingsmiljø. Lad os se på de tre mest populære af dem:
kompilering af moduler i Turbo Pascal
Resultatet af at kompilere modulet til Turbo Pascal, vil der være en fil med filtypenavnet .tpu (Turbo Pascal enhed), gemmer dens kode.
kompilering af moduler i Free Pascal
Efter at have kompileret modulet i miljøet Gratis Pascal, oprettes to filer med forskellige opløsninger: .ppu Og .o. Den første indeholder grænsefladedelen af modulet, og den anden (nødvendig for at sammensætte programmet) indeholder en del af implementeringerne.
kompilering af moduler i Pascal ABC.NET
Pascal ABC.Net genererer ikke maskinsprogkode under modulkompilering. Hvis kompileringen lykkes, gemmes koden i en fil med permission.pcu.
Der er tre kompileringstilstande for programmeringsmiljøerne Turbo Pascal og Free Pascal: Kompiler, Lav og byg. I kompileringstilstand skal alle moduler, der bruges i programmet, være kompileret på forhånd. Applikationen i Make compilation-tilstand kontrollerer alle tilsluttede moduler for tilstedeværelsen af filer med den passende opløsning til programmeringsmiljøet (.tpu eller .o). Hvis nogen af dem ikke findes, søges der i en fil med navnet på det ufundne modul og filtypen .pas. Den mest pålidelige tilstand er Byg. Søgning og kompilering af filer (med filtypenavnet .pas) i denne tilstand sker, selv når der allerede findes modulære filer.
Eksempel: lad os lave et lille modul, der indeholder procedurer til binær og lineær søgning af elementer i et array. Modulkode:
Enhedssøgning; Interface type arr = matrix af heltal; var s: streng; procedure binær_søgning(x: heltal; Ar: arr; var s: streng); procedure line_search(x: heltal; Ar: arr; var s: streng); Implementering var a, b, c, i: heltal; procedure binær_søgning(x: heltal; Ar: arr; var s: streng); begynde a:=1; b:=5; s:="NEJ"; mens a<=b do
begin
c:=a+(b-a) div 2;
if (x
ende; ende; procedure line_search(x: heltal; Ar: arr; var s: streng); begynder s:="NEJ"; for i:=1 til 5 begynder hvis (Ar[i]=x), så begynder s:="JA"; pause;
ende;
ende; ende; ende.