Prognyelvek portál

Standard könyvtár felépítése

A Modula-3 standard könyvtára viszonylag tömör, és csak a legalapvetőbb rutinokat tartalmazza. A modulok nagy része egy bizonyos T típuson operál, a típus megvalósítása attól függ, hogy mi a modul. A könyvtárakat három részre csoportosíthatjuk:

String rutinok: A Modula-3 a sztringeket kétféleképpen támogatja. Az egyik a beépített alaptípus, a TEXT; a másik pedig a Text modulon keresztül. A Text interface-ben a T típus a beépített TEXT. Az interface átjárást biztosít a TEXT és az ARRAY OF CHAR típusok között a következő műveletekkel:
- PROCEDURE SetChars(VAR a: ARRAY OF CHAR; t: T);
- PROCEDURE FromChar(ch: CHAR): T;
- PROCEDURE FromChars(READONLY a: ARRAY OF CHAR): T;
Ezen kívül tartalmazza az alap eljárásokat TEXT típusú sztringeken: összehasonlítás (Equal: megmondja, hogy két sztring megegyezik-e, vagy nem; Compare: -1, 0 vagy 1 eredményt ad a lexikografikus rendezés szabályának megfelelően), i. pozíciójú karakter lekérdezése, hosszmeghatározás, részsztring. Kereshetünk sztringben karaktert, erre két függvényt is ad a könyvtár:
- PROCEDURE FindChar(t: T; c: CHAR; start := 0): INTEGER;
  visszaadja a legkisebb i indexet, amelyre teljesül, hogy az i. pozíción lévő karakter = c úgy, hogy i>=start
- PROCEDURE FindCharR(t: T; c: CHAR; start := LAST(INTEGER)): INTEGER;
  visszaadja azt a legnagyobb i indexet, amelyre teljesül, hogy az i. pozíción lévő karakter = c úgy, hogy i<=start
Mindkét fenti függvény -1 visszatérési értékkel tér vissza, ha a keresett karakter nem található, vagy a start értéke nem megfelelő.
Érdemes még egy eljárásról szót ejteni:
- PROCEDURE Hash(t: T): Word.T;
  A t sztring hash értékét adja vissza
Az Fmt és a Scan interface további konverziókat támogatnak TEXT és INTEGER/REAL/BOOLEAN típusok között, illetve fordítva. Ezek közül néhány eljárás (a többi típushoz a konvertálás hasonlóan):
- PROCEDURE Bool(b: BOOLEAN): TEXT;
- PROCEDURE Char(c: CHAR): TEXT;
- PROCEDURE Int(n: INTEGER; base: Base := 10): TEXT;
- PROCEDURE Real(txt: TEXT): REAL RAISES {Lex.Error, FloatMode.Trap};
Ha TEXT-ből konvertálunk, akkor a szövegben lévő esetleges "white-space"-eket kihagyják a rutinok, a "white-space" karaktereket a Lex.Blanks konstans definiálja. Az ilyen irányú konvertálások persze nem mindig sikeresek, ha a megadott szöveg nem konvertálható, akkor Lex.Error kivételt kapunk.
A Modula-3 standard könyvtára négy interface-t definiál input/output műveletek számára: az IO, Rd, Wr és Lex modulokat. Továbbá definiálja a reader és writer streameket, előbbi input-, utóbbi outputstream. Ezek konkrét megvalósításai az stdin (standard input, általában a billentyűzet) és az stdout (standard output, általában a képernyő).
- Az IO interface definiálja az alapvető i/o műveleteket, az alaptípusok beolvasását és kiírását; A műveleteket Wr.T és Rd.T típusú streameken definiálja, amelyek alapértelmezésben az stdin és stout.
- Az Rd interface valósítja meg az input stream műveleteit, amelynek az alapművelete a GetChar, ami visszaadja a stream aktuális pozícióján lévő karaktert. Az Rd stream kiterjeszthető olyan streamre, amelyben tetszőleges pozícióról is olvashatunk (seekable).
- Ehhez hasonlóan a Wr interface az outputstream műveleteket definiálja, itt a PutChar az alapeljárás.
A harmadik csoportba tartozik néhány egyéb interface. A Params modul segítségével megkaphatjuk a program indításakor adott paramétereket, a Count konstans tartalmazza a paraméterek számát, értéküket pedig a Get eljárással kérdezhetjük le. Az Env interface is paraméterek lekérdezésére használható, de itt nem a program paramétereit, hanem a rendszer környezetváltozóit érhetjük el:
- PROCEDURE Get(nm: TEXT): TEXT; (* kornyezeti valtozo erteke nev szerint *)
- PROCEDURE GetNth(n: CARDINAL; VAR (*OUT*) nm, val: TEXT); (* kornyezeti valtozo erteke index szerint *)

Simple Input Output

Eljárásai: SIO.GetInt, SIO.PutInt, SIO.GetChar, SIO.PutChar, SIO.GetReal(honnan), SIO.PutReal(mit, hova), SIO.LookAhead: előreolvasás.

Filekezelés

A Modula-3 önmagában nem biztosít lehetőséget a fájlkezelésre. A legtöbb programnyelvhez hasonlóan, ez nem azt jelenti, hogy közvetlenül az operációs rendszerrel kell kommunikálnunk: a Modula-3 nyelvi környezete biztosítja azokat az objektumokat és eljárásokat amelyek kezelik az operációs rendszer felé történő hívásokat.

Input és output adatfolyam

A Modula-3 nyelvi környezete input és output adatfolyamokat biztosit fájlok hozzáféréséhez. Ezek a nyelv standart könyvtárában vannak definiálva, reader és writer néven. Ezek olyan objektumok, melyeket összekapcsolhatunk egy fájllal az inicializáció során. Arra is van lehetőség, hogy egy output adatfolyamot a monitorhoz vagy a nyomtatóhoz társítsuk vagy egy input adatfolyamot egy input eszközzel mint például a billentyűzet.


	MODULE ReadFile EXPORTS Main; 	 
	IMPORT Rd, FileRd, SIO, SF; 	 
	CONST FileName = "input.dat";  

	VAR rd: Rd.T; 	 
    	t: TEXT;  	 
   	IF SF.FileExists(FileName) THEN 	 
          rd:= FileRd.Open(FileName);     	(*kapcsolatot epit fel egy fajllal  *)
    	WHILE NOT Rd.EOF(rd) DO 	(*fajl vege ellenorzes*)
    	     t:= Rd.GetLine(rd);          	(*olvasás a sorvegeig *)
    	     SIO.PutText(t); SIO.NIQ; 	 
    	 END; 	 
    	Rd.Close(rd)  	(*fajl bezarasa*)
	 END (*IF*) 	 
	END ReadFile.


	VAR rd: Rd.T;  BEGIN
	rd= FileRd.Open("input.dat");


	t:= Rd.GetLine(rd);


	c:= Rd.GetChar(rd);


	Rd.EOF(rd)
	MODULE WriteFile EXPORTS Main;   	 
 	 
	IMPORT Wr, FileWr; 	 
	 
	CONST FileName="output.dat";   	 
  	 
	VAR wr: Wr.T; 	(*iro objektumt*)
    BEGIN 	 
       wr:=FileWr.Open(FileName);  	(*kapcsolatot epit fel egy fajllal  *)
       Wr.PutText(wr, "first line\n"); 	(*kimenet fajlba  *)
       Wr.PutText(wr, "2\n"); 	 
       Wr.PutText(wr, "--End--\n"); 	 
       Wr.Close(wr) 	(* bezarja a fajlt *)
  END WriteFile.

Mielőtt elkezdenénk olvasni egy fájlt általában szükséges megvizsgálni, hogy hozzáférhető-e, az SF.FileExits függvényt használja erre. A függvény visszatérési értéke true lesz ha a fájl olvasható. Az SF (simple file) modul tartalmaz olyan hasznos utility függvényeket, amelyek egyszerűbbé teszik a gyakran használt fájlkezelő funkciókat mint a rugalmasabb de sokkal komplikáltabb könyvtári függvények

A fájl írás ezzel analóg módon történik: társítunk egy output adatfolyamot egy a háttértárolón lévő fájllal. Ha a fájl még nem létezik automatikusan létrejön. Ha létezik már ilyen nevű fájl akkor az újonnan létrehozott fájl felülírja a régit és annak tartalma elveszik. A WrPutText vagy a Wr.PutChar eljárásokkal írhatunk fájlba.
Ezek absztrakt modulok annyiban, hogy csak a bemeneti és kimeneti adatfolyamok viselkedését definiálják. Ezeknek a moduloknak az eljárásai olyan metódusokat hívnak meg, amelyekkel az összes bemeneti vagy kimeneti adatfolyamnak rendelkeznie kell. Az Rd.T és Wr.T objektumok ezeket a metódusokat, csak mint üres vázakat tartalmazzák. Az Rd.T és Wr.T altípusok implementálóinak a feladata , hogy életet leheljenek ezekbe a metódusokba. A FileRd és FileWr modulok ilyen altípusokat implementálnak. Úgy viselkednek mint az Rd.T vagy Wr.T , és birtokolják az összes szükséges metódust fájlok olvasásához és írásához az operációs rendszer szolgáltatásain keresztül. Ily módon a Modula-3 könyvtár meghatároz egy fogalmat fizikai közegek olvasására és írására és biztosítja az egységességet. Hasonló képen írhatunk a képernyőre és a nyomtatóra vagy fájlokba. Még a programok közötti kommunikáció is lehetséges speciális input és output adatfolyamokkal.(adatfolyamokat csatornákhoz köthetünk. Az alábbi táblázat néhány input/output eszköz nevét mutatja, a megfelelő input és output adatfolyam objektumokat implementáló modulokkal együtt

Fájl írás/olvasás	FileRd/FileWr
Képernyőre írás	Stdio: output adatfolyam stdout
Billentyűzetről olvasás	Stdio: input adatfolyam stdin
Nyomtatóra írás	Operációs rendszer függő; általában FileWr-en keresztűl speciális fájlnévvel

Seekable

A Seek eljárás lehetőséget nyújt egy a háttértárolón lévő megnyitott fájlban az írási, olvasási pozíció megváltoztatására. Nem minden adatfolyam bír a Véletlenszerű hozzáférés tulajdonsággal. ( a billentyűzet és a képernyő nem ilyenek) A tulajdonság meglétének ellenőrzése a Seekable függvénnyel lehetséges. Az aktuális pozíciót az Index adja vissza.

Szakasos

Néhány input adatfolyam nem képes folyamatosan új adatot biztosítani (bár még nem értünk az adatfolyam végére); az Rd.GetChar meghívása megszakításos bemeneti adatfolyam esetén blokkolja a programot, amíg új adatok lesznek elérhetőek. A billentyűzetet is ilyen adatfolyam: amíg a felhasználó nem visz be adatot a program várakozik. Ezt az attribútum ellenőrizhető a Rd.Intermitt függvénnyel.

Pufferelt

Sok esetben az adatok nem íródnak ki azonnal egy output adatfolyamra annak érdekében, hogy az átviteli sebességet javítsák. merevlemezre való írás például majdnem ugyanannyi ideig tart egy teljes adatblokk esetén, mint egyetlen bájt esetén. Emiatt az adatokat a főmemóriában tároljuk egy pufferben és akkor írjuk ki őket ténylegesen amikor kitesznek egy teljes blokkot. A merevlemez tipikus blokkméretei a következők:512, 1024, 4096 bájt. Ez azt jelenti, hogy figyelnünk kell arra, hogy a program ne termináljon ha még adat van a pufferben. Wr.Flush explicit módon kiírja a puffer tartalmát, mielőtt az betelne, így módon az adatok folyamatosságát biztosíthatjuk.. Azt hogy van-e puffer a program és az output adatfolyam között a Wr.Buffer függvénnyel ellenőrizhetjük. Nem pufferelt output adatfolyam esetén minden egyes írás funkció hívásakor a hívó programnak addig kell várnia, amíg az adat fizikailag nem tárolódik. Az input adatfolyamoknak mindig puffereltnek kell lennie, mivel az adatok az eszköz sebességével (vagy a felhasználó gépelési sebességével jönnek) ami gyorsabb lehet, mint amit a program el tud olvasni. Az input puffer ciklikus listaként funkcionál: ha a program gyorsabb, mint a beviteli eszköz (vagyis a puffer üres), akkor a program várakozik. Ha a beviteli eszköz a gyorsabb akkor az adatot összegyűjti a puffer. Ha a puffer betelik akkor a beviteli eszköz kénytelen várakozni.


	PROCEDURE PutRealArray(wr: Wr.T; READONLY r: ARRAY OF REAL)=
	BEGIN
		FOR i:= FIRST(r) TO LAST(r) DO
			Wr.PutText(wr, Fmt.lnt(i) & "" & Fmt.Real(r[ij) & "\n");
		(*index ertek *)
		END; (*FOR*)
	END PutRealArray;

Fmt és Scan

Mind az Rd és a Wr csak olyan eljárásokat tartalmaz, amelyek segítségével karaktereket lehet írni és olvasni. (a TEXT típus egy karakter sorozat). Ezek a modulok csak nyers adatot átvitelét képesek kezelni Ahhoz, hogy számokat vagy Boolean típusokat tudjunk tárolni, először formázni kell azokat; vagyis ahhoz hogy olyan formára alakítsuk őket, amit a Wr fel tud dolgozni, át kell alakítani az értékeket a nekik megfelelő TEXT reprezentációra. Például ha egy Boolean értéke true akkor a text reprezentációja "TRUE" lesz. Ellenkező irányban, az olvasásnak vissza kell konvertálnia a szöveget annak az eredeti típusára. Úgy mondjuk, hogy letapogatjuk a szöveget, hogy megszerezzük az adatokat. Szöveg fájlok használata több tárhelyet igényel a fájlhoz, de meg van az előnye, hogy a fájl tartalma olvasható. Az Fmt és Scan modulok az alaptípusokat konvertálják TEXT típusra és vice versa. Az eljárás ezért azt a tényt használja ki, hogy az indexeket és érékeket a következő képen tároljuk:


	index blank value EOL


	PROCEDURE GetRealArray(rd: Rd.T; VAR r: ARRAY OF REAL)=
	VAR i, delimiter: CARDINAL; t: TEXT;
	BEGIN
		WHILE NOT Rd.EOF(rd) DO
			t:= Rd.GetLine(rd);
			delimiter:= Text.FindChar(t, ' ');                                    
		    (*index és érték között *)
			i:= Scan.lnt(Text.Sub(t, 0, delimiter));                           
		    (*index számláló *)
		     r[i]:= Scan.Real(Text.Sub(t, delimiter+l, Text.Length(t)-delimiter-1));
		    (*ertek *)
        END; (*WHILE*)
    END GetRealArray;


	CONST NumbLength = 10;
	PROCEDURE PutRealArray(wr: Wr.T; READONLY r: ARRAY OF REAL)=
	  BEGIN
	    FOR i:= FIRST(r) TO LAST(r) DO
			(*iras allando hosszal *)
		     Wr.PutText(wr, Fmt.Pad(Fmt.lnt(i), NumbLength) &
             Fmt.Pad(Fmt.Real(r[i]), NumbLength) &"\n");
	    END; (*FOR*)
	  END PutRealArray;

	PROCEDURE GetRealArray(rd: Rd.T; VAR r: ARRAY OF REAL) _
	  VAR i: CARDINAL;
	  BEGIN
	      WHILE NOT Rd.EOF(rd) DO
	          i:= Scan.lnt(Rd.GetText(rd, NumbLength));
				(*index szamlalo*)
	          r[i]:= Scan.Real(Rd.GetText(rd, NumbLength));
				(*érték számláló*)
	          EVAL Rd.GetLine(rd);
				(*skip EOL*)
	      END; (*WHILE*)
    END GetRealArray;


	PROCEDURE Scan(rd: Rd.T; READONLY cs: SET OF CHAR := NonBlanks): TEXT
	RAISES {Rd.Failure, Alerted};


      PROCEDURE Skip(rd: Rd.T; READONLY cs: SET OF CHAR := Blanks)
      RAISES {Rd.Failure, Alerted};


	PROCEDURE Match(rd: Rd.T; t: TEXT) RAISES {Error, Rd.Failure, Alerted};


	CONST
		Blanks = SET OF CHAR{
			' ', '\t', '\n', '\r', '\013'  vertical tab , '\f'};
		NonBlanks = SET OF CHAR{'!' .. '~'};


	PROCEDURE Bool(rd: Rd.T): BOOLEAN RAISES {Error, Rd.Failure, Alerted};
	PROCEDURE Int(rd: Rd.T; defaultBase: [2..16] := 10): INTEGER RAISES {Error, FloatMode.Trap, Rd.Failure, Alerted};
	PROCEDURE Unsigned(rd: Rd.T; defaultBase: [2..16] := 16): Word.T RAISES {Error, FloatMode.Trap, Rd.Failure, Alerted};
	PROCEDURE Real(rd: Rd.T): REAL RAISES {Error, FloatMode.Trap, Rd.Failure, Alerted};
	PROCEDURE LongReal(rd: Rd.T): LONGREAL RAISES {Error, FloatMode.Trap, Rd.Failure, Alerted}; 
	PROCEDURE Extended(rd: Rd.T): EXTENDED RAISES {Error, FloatMode.Trap, Rd.Failure, Alerted};

A Modula3 programozási nyelv

Szabványos könyvtárak