A DOS unit fontosabb beépített konstansai, függvényei, eljarasai; hasznalata

A DOS unit fontosabb beépített konstansai, függvényei, eljárásai; használata:

A DOS unit szerepe, jelentõsége a Pascal programok készítése során:

Minden programozási nyelv esetén megfigyelhetõ a fejlesztõrendszer, az adott nyelv és az operációs rendszer szoros kapcsolata. Igaz ez a megállapítás minden operációs rendszerre és minden programozási nyelvre. Akár a C nyelvet és a Linux operációs rendszert választjuk, akár a Delphi fejlesztõrendszert, amely Windows 9x alatti programok készítésére alkalmas, akár a Turbo Pascal és a DOS kapcsolatát vizsgáljuk meg, mindenütt tapasztalható, hogy a programozási nyelv esz 242d38c közei és az operációs rendszer szoros kapcsolatban állnak egymással.
A programozás során felmerülhetnek olyan problémák, melyek csak az operációs rendszeren keresztül oldhatók meg. Nagyon jó példa erre a filekezelés. Találkozhatunk azonban olyan estekkel is, amikor az operációs rendszer alacsonyszintû szolgáltatásait (megszakítások) kell igénybe vennünk, vagy éppen egy BIOS hívás segítségével tudjuk megoldani a feladatot. Az utóbbi az esetben is az operációs rendszeren keresztül tudjuk elérni a BIOS szubrutinjait.
A Turbo Pascal környezetben ezt a kapcsolatot a DOS unit biztosítja, ez a unit tartalmazza azokat az eljárásokat, függvényeket, konstansokat, amelyek szükségesek az operációs rendszer szolgáltatásainak igénybevételéhez. Ezen túlmenõen a System unit egy része is ezt a kapcsolatot hivatott erõsíteni, a legalapvetõbb problémák a System unit eljárásaival, függvényeivel oldhatók meg.

A System unit fontosabb változói, függvényei, eljárásai:

Az egyik legalapvetõbb lehetõség az operációs rendszer és a program között megvalósított paraméterátadás. Lehetõségünk van arra, hogy a programunkban olyan paramétereket használjunk, melyeket a felhasználó a program indításakor a parancssorban ad meg (Hasonlóan, mint a DIR parancs paramétereit, pld: DIR C:\WINDOWS). Jó példa erre, amikor egy olyan programot szeretnénk írni, amely megkeres egy állományt a lemezen. Ha a program indításakor megadta a felhasználó a keresett állomány nevét, akkor azonnal elkezdjük a keresést, ha nem adott meg nevet, akkor a keresés elõtt rákérdezünk, mit szeretne keresni. A paraméterátadás problémáját a System unitban oldották meg, két függvény segítségével.

ParamCount függvény:
A program paramétereinek száma. Szintaxisa: PSzam:= ParamCount;
A függvény Word tipusú értékkel tér vissza. A függvény a parancssorban megadott paramétereket veszi figyelembe. Külön paraméternek számítanak az egymástól szóközzel elválasztott értékek. Ezalól csak az elsõ paraméterként megadott érték kivétel, melyet bármilyen DOS által elfogatott karakterrel elválaszthatunk a program nevétõl. Tehát ha a parancssor:
PARPROBA/W /E /D
ahol PARPROB.EXE a futtatható állomány, a ParamCount által visszaadott érték 3 lesz.

ParamStr függvény:
A program paramétereinek értéke. Szintaxisa: Par1:= ParamStr(ParSzam);
A függvény String tipusú értékkel tér vissza. A ParSzam határozza meg, hogy hanyadik paramétert kérdezzük le. A ParSzam Word tipusú változó vagy konstans lehet. Tehát ha a parancssor:
PARPROBA/W /E /D
ahol PARPROB.EXE a futtatható állomány, a ParamStr(1) függvény értéke: /W, ParamStr(2) értéke: /E, ParamStr(3) értéke: /D. Ha a ParamStr függvényt a 0. paraméter lekérdezésével hívjuk meg, a visszaadott érték a futtatható állomány neve és elérési útja lesz. Ha a ParamCount függvény által szolgáltatott értéknél nagyobb számot alkalmazunk, tehát egy nem létezõ paraméterre hivatkozunk, a ParamStr függvény üres string értéket ad vissza
 

A másik szintén a System unit által megoldott probléma az állományok és könyvtárak kezelése. Az állományok kezelése nem kapcsolódik szorosan ide (részletezve a 10-es tételben), bár az operációs rendszer szolgáltatásai közé tartozik. A könyvtárkezelõ eljárások, függvények tárgyalása (rövidsége miatt is) ide tartozhat. (ZKerekes szerint).

ChDir eljárás:
Könyvtárváltás. Szintaxisa: ChDir(Konyvtar);
Az eljárás paramétereként meg kell adni a könyvtár teljes elérési útját, meghajtóval együtt. Pld.: ChDir('C:\WINDOWS');

MkDir eljárás:
Könyvtár létrehozása. Szintaxisa: MkDir(Konyvtar);
Az eljárás paramétereként meg kell adni a könyvtár teljes elérési útját, meghajtóval együtt. Pld.: ChDir('C:\SAJAT');

RmDir eljárás:
Könyvtár törlése. Szintaxisa: RmDir(Konyvtar);
Az eljárás paramétereként meg kell adni a könyvtár teljes elérési útját, meghajtóval együtt. Pld.: ChDir('C:\VACAK');
Az eljárás alkalmazása során figyelembe kell venni a DOS alatt végzett könyvtártörlés szabályait, tehát itt is csak olyan üres könyvtárat tudunk törölni, amely éppen nem az aktuális könyvtár, és az aktuális könyvtárnál alsóbb szinten helyezkedik el a könyvtárrendszerben.

GetDir eljárás:
Aktuális könyvtár lekérdezése. Szintaxisa: GetDir(Drive, Konyvtar);
Az eljárás paraméterei:
Drive: Byte - Meg kell adnunk annak a meghajtónak a számát, amelyiken szeretnénk az aktuális könyvtárat lekérdezni. Számozás: 0 - aktuális meghajtó; 1 - A: meghajtó; 2 - B: meghajtó; 3 - C: meghajtó; ...
Könyvtar: String - Minden esetben egy változó. Ebben a változóban kapjuk vissza a könyvtár elérési útját és nevét.
 
 

A DOS unit fontosabb beépített konstansai, változói:

Ahogy az elõbb láthattuk a System unit is tartalmaz néhány eljárást, függvényt, amely az operációs rendszerrel való kapcsolat létesítését segíti, de az ilyen célú alprogramok, változók, konstansok, típusok legnagyobb része a DOS unitban kapott helyet.

A DOS unit beépített konstansai:
A beépített konstansok legfontosabb csoportját a file-attribútumokhoz kapcsolódó konstansok alkotják, amelyeket felhasználhatunk az olyan eljárásoknál (értelemszerûen), amelyek a file-ok attribútumát módosítják, de fontos szerepük van a file-ok keresése során is. A konstansok:
 
 

A DOS unit beépített változói:
A DOS unit legfontosabb beépített változója a DosError változó. Mint a nevébõl is látszik a hibakezelés során játszik jelentõs szerepet. A DosError változó segítségével tudjuk figyelni, hogy a DOS unit eljárásai sikeresen befejezõdtek-e. Természetesen egy operációs rendszer szintû hiba - hiszen ezek az eljárások ilyen hibával szakadnak meg - alapértelmezés szerint megszakítaná a program futását, ezért ha magunk szeretnénk ezeket a hibákat kezelni, akkor az direktívát kell alkalmaznunk. Ha a saját hibakezelést választjuk (egyes esetekben célszerû), nagyon figyelmesen kell eljárnunk, mert egy lekezeletlen hiba a program megszakításánál súlyosabb következményekkel járhat. Nézzünk egy példát az eddig leírtakra.
Hozzunk létre a C: meghajtón egy könyvtárat, amelynek neve legyen SAJAT.

Automatikus hibakzelés alkalmazása:

Uses DOS;
Begin
    MkDir('C:\SAJAT');
    Writeln('A C:\SAJAT konyvtarat letrehoztuk');
End.

Ha valamilyen hiba lép fel a program futtatása során - mondjuk a könyvtár már létezik - futás közbeni hiba lép fel, a program angolul kiirja a hibauzenetet és megszakad.

Saját hibekezelés alkalmazása:

Uses DOS;
Begin
   
   
   
    MkDir('C:\SAJAT');
   

   
    If DosError<0
        then Begin
           
            Writeln('Hiba lepett fel a konyvtar letrehozasa soran');
           
            Halt(1);
        End;
 
   
    Writeln('A C:\SAJAT konyvtarat letrehoztuk');
End.

A második megoldás esetén a hibakezelést magunk végezzük el. A hibát okozó mûvelet elõtt az I direktíva kikapcsolásával letiltottuk a futás közben fellépõ I/O hibák automatikus kezelését. A kritikus mûvelet után célszerû a direktívát bekapcsolni, mivel ez az alapértelmezett érték, és a programtovábbi részében is elõfordulhatnak hasonló hibák, esetleg olyanok, amelyekre nem számítunk, és nem is gondoljuk, hogy ezeket le kellene kezelnünk. A mûvelet után ellenõrizzük a DosError változó értékét, amely a mûvelet sikeres befejezése után 0, egyébként a hiba kódját tartalmazza. Ennél az egyszerû programnál a hibakezelés a hibaüzenet kiirásából és a program megszakításából áll, de ennél sokkal bonyolultabb esetek is elõfordulhatnak.

A Dos hibák kódjai:
Ezeket az értékeket veheti fel a DosError változó futási hiba esetén.

0: nincs hiba
2: a file nem létezik
3: az útvonal nem létezik
5: a hozzáférés nem megengedett
6: helytelen file-kezelés
8: kevés a memória
10: helytelen környezet (DOS környezeti változó beállításánál)
11: helytelen formátum
18: nincs több file (keresésnél)
 

A DOS unit beépített típusai:
A beépített típusok egyik része a DOS unit eljárásai, függvényei által elõállított eredmények kezelését teszi egyszerûbbé, másik része a megszakításkezelést, a regiszterek elérését, kezelését segíti.

Registers: record
A regiszterek eléréséhez a deklarációs részben fel kell vennünk egy változót, amelynek típusa Registers lesz. A Registers típus a DOS unit beépített típusa, rekord tipus. Mezõi segítségével elérhetõvé válnak a processzor regiszterei. Használata:

Uses DOS;
Var R: Registers;
Begin
    ...
    R.AH:= $09;
    R.AH:= 65;
    ...
End.

A Registers rekord mezõi a processzor regiszterei:
AX, BX, CX, DX, BP, SI, DI, DS, ES, Flags: Word; - 16 bites regiszterek (bõvebben lásd Assembly-nél)
AH, AL, BH, BL, CH, CL, DH, DL: Byte; - 8 bites regiszterek, az elõzõ regiszterek alsó és felsõ byte-ja

DateTime: record
Az idõ és a dátum kezelését segítõ típus. Mezõi:
Year,
Month,
Day,
Hour,
Min,
Sec: Word;

SearchRec: record
A file-ok keresése során alkalmazott FindFirst és FindNext eljárások használnak ilyen tipusú változókat. Az egyes mezõkben a keresõ eljárások által megtalált állomány adatai vannak tárolva.
Fill: Array [1..21] of Byte;
Attr: Byte;
Time: Longint;
Size: Longint;
Name: String[12];
 

A DOS unit eljárásai, függvényei, a DOS unit használata:
 A DOS unit használatához a deklarációs részben szerepelnie kell a következõ sornak:
Uses DOS;

A DOS unit fontosabb eljárásait, függvényeit az alábbi négy csoportba sorolhatjuk:
- Katalógus (könyvtár) és lemezkezelés
- Dátum és idõ kezelése
- Külsõ programok indítása
- Megszakítások kezelése

Katalógus és lemezkezelés:
Ezeknek az eljárásoknak, függvényeknek az állományok kezelése során van fontos szerepük.

FindFirst eljárás:
Az elsõ megfelelõ bejegyzés keresése. Szintaxisa: FindFirst(Ut, Attr, Rek);
Ut: String - meghatározza, hogy melyik könyvtárban keressük a feltételeknek megfelelõ állományt.
Attr: Byte - meghatározza, hogy a bejegyzés milyen attribútumokkal rendelkezik. Az attribútumokhoz tartozó konstansokat lásd fentebb. Elsõsorban akkor van szerepe, ha könyvtárakat keresünk. Általában az AnyFile konstans kerül erre a helyre, ekkor minden állományt és könyvtárat figyelembe veszünk a keresésnél.
Rek: SearchRec - a keresés eredménye. Az eljárás végrehajtása után a Rek rekord mezõiben találjuk meg az állomány (könyvtár) jellemzõit. Minden esetben egy változót kell átadni az eljárásnak.

Pld:
FindFirst('C:\TP\*.PAS', AnyFile, Rek);

A keresett bejegyzés lehet egy állomány és egy könyvtár egyaránt, ezt az Attr paraméter értéke határozza meg. Általában a FindNext eljárással együtt használjuk, az összes olyan állomány keresésére, amelyek valamilyen feltételnek eleget tesznek. Ha nem talál a feltételeknek megfelelõ bejegyzést az eljárás, a DosError változó értékét 18-ra állítja, ha az Ut paraméterben  megadott könyvtár nem létezik, akkor a DosError változó értékét 2-re állítja.

FindNext eljárás:
A következõ megfelelõ bejegyzés keresése. Szintaxisa: FindNext(Rek);
Rek: SearchRec - egy elõzõleg a FindFirst eljárás által feltöltött rekord. Minden esetben változót kell átadni az eljárásnak, mivel az eredményt is ebben a rekordban kapjuk vissza.
A FindFirst eljárás után ciklusban alkalmazva megkereshetjük az összes adott feltételnek megefelelõ bejegyzést az adott könyvtárban. Ha az eljárás nem talál megfelelõ bejegyzést, akkor a DosError változó értékét 18-ra állítja.

A FindFirst és FindNext eljárások együttes alkalmazására példa a Feladatok lapon található, a Rendszerprogramozás részben: Feladat

FSearch függvény:
Megadott állomány keresésére szolgál. Szintaxisa: FSearch(FNev, Ut);
FNev: PathStr; - az állomány neve. A PathStr a DOS unit egyik kevésbé fontos beépített típusa, deklarációja:
type PathStr= String[79]; Tehát tulajdonképpen egy String[79] tipusú paraméterrõl van szó. Az állomány nevén kívül megadhatunk itt egy útvonalat is, ahol az állományt elõször keresi az eljárás. Összefoglalva az állománynevet kétféleképpen lehet megadni: vagy csak a nevet és a kiterjesztést adjuk meg (pld. TURBO.EXE) vagy megadjuk az útvonalat is (C:\TP\BIN\TURBO.EXE). (Bár az utóbbinak nincs túl sok értelme, lévén szó egy olyan eljárásról, amelynek az a feladata, hogy keressen meg egy állományt.)
Ut: String; - Ebben a paraméterben adhatjuk meg, hogy mely könyvtárakban keresse az eljárás a megadott állományt. A DOS Path környezeti változójához hasonló formában adhatjuk meg a kívánt könyvtárakat, pontosvesszõvel elválasztva.

Pld.: Keressük meg a TURBO.EXE állományt, a keresés során vegyük figyelembe a következõ könyvtárakat:
C:\, C:\WINDOWS, C:\TP, C:\TOOLS

FSearch('TURBO.EXE', 'C:\;C:\WINDOWS;C:\TP;C:\TOOLS');

A fenti három alprogram egy összetettebb alkalmazására szeretnék egy példát hozni, de mivel ebben más eljárások, függvények is szerepelnek, ez a tétel végére került.
 

Dátum és idõ kezelése:
A DOS unit segítségével tudjuk módosítani, illetve lekérdezni a rendszerdátumot és a rendszeridõt Pascal programjainkból. Lekérdezhetjük, illetve módosíthatjuk az állományok utolsó módosításának dátumát és idejét. A rendszeridõ és rendszerdátum kezelése egyszerûbb, nézzük elõször azt. A rendszeridõ és dátum kezeléséhez a következõ eljárásokra van szükségünk:

GetTime eljárás:
A rendszeridõ lekérdezése. Szintaxisa: GetTime(Ora, Perc, MP, SzMP);
Az Ora, Perc, MP, SzMp Word tipusú változók, az eljárás végrehajtása után ezek tárolják a visszaadott idõpontot.

GetDate eljárás:
A renszerdátum lekérdezése. Szintaxisa: GetDate(Ev, Ho, Nap, NapNev);
Az Ev, Ho, Nap, NapNev Word típusú változók. Az elõzõ eljáráshoz hasonlóan mûködik, egyetlen eltérés a NapNev nevû változó, amelyben a nap sorszámát kapjuk meg. A sorszám alapján kiiratható a nap neve. A sorszámozás 0-tól 6 ig tart a következõképpen: 0- Vasárnap; 1- Hétfõ; 2- Kedd; ... 6- Szombat.

SetTime eljárás:
A rendszeridõ beállítása. Szintaxisa: SetTime(Ora, Perc, MP, SzMP);
Hasonlóan mûködik a rendszeridõ lekérdezéséhez, a különbség annyi, hogy itt már nemcsak változókat, hanem konstans értékeket is használhatunk.

SetDate eljárás:
A rendszerdátum beállítása. Szintaxisa: SetDate(Ev, Ho, Nap, NapNev);
Hasonlóan mûködik a rendszerdátum lekérdezéséhez, a különbség annyi, hogy itt már nemcsak változókat, hanem konstans értékeket is használhatunk.

A rendszerdátumot és renszeridõt kezelõ eljárások alkalmazására példa a Feladatok lapon található, a Rendszerprogramozás részben: Feladat
 

A DOS unit beépített tipusainál találkoztunk már a SearchRec rekorddal, amely egy állomány adatait tartalmazza. A rekord mezõi között szerepel - sok más mellett - az állomány utolsó módosításának ideje. A Time mezõ tipusa azonban Longint, ez tartalmazza a szükséges dátumot és idõt. A Turbo Pascal (szûkebben értelmezve a DOS unit) kétféle dátumot ismer: tömörítetlen dátum, amely egy DateTime tipusú rekordban helyezkedik el, illetve a tömörített dátum, amelyet egy Longint tipusú változóban tárolhatunk. A kétféle dátumforma között két eljárás biztosítja az átjárhatóságot (konverziót).

PackTime eljárás:
Tömörítelen dátum (rekord) konvertálása Longint formátumba. Szintaxisa: PackTime(D, L);
D: DateTime; - a tömörítendõ dátumot tartalmazó változó.
L: Longint; - a tömörített dátumot tároló változó.
Az eljárás mindkét paramétere változó kell legyen. A D változóban tárolt dátumot az eljárás tömöríti, a tömörített dátumot az L változóban adja vissza.

UnPackTime eljárás:
Tömörített dátum (Longint) konvertálása Record formátumba. Szintaxisa: UnPackTime(L, D);
L: Longint; - a tömörített dátum. Változó és konstans lehet egyaránt.
D: DateTime; - a kicsomagolt dátumot tároló rekord tipusú változó.
Az eljárás elsõ paramétere változó és konstans egyaránt lehet, a második paraméter csak változó lehet, mivel ebben kapjuk vissza a kitömörített dátumot.

A fenti két eljárást kell alkalmaznunk, amikor egy FindFirst vagy FindNext eljárás által megtalált file utolsó móosítási dátumához szeretnénk hozzáférni, és akkor is amikor egy általunk meghatározott állomány adataira vagyunk kiváncsiak.

GetFTime eljárás:
A file utolsó írásának idejét kérdezhetjük le ezzel az eljárással. Szintaxisa: GetFTime(F, T);
F: File; - az állományleíró változó. Mielõtt a GetFTime eljárást használnánk, az állományhoz egy állományleíró változót kell hozzárendelni az Assign eljárás segítségével. Bõvebben lásd a Filekezelésnél (10-es tétel).
T: Longint; - a tömörített idõt tároló változó. Ez a paraméter minden esetben egy változó kell legyen.

SetFTime eljárás:
A file utolsó írásának idejét állíthatjuk be ezzel az eljárással. Szintaxisa: SetFTime(F, T);
Az eljárás használata a GetFTime eljáráshoz hasonlóan történik, annyi különbséggel, hogy itt a T nemcsak változó, hanem konstans érték is lehet.
 

Külsõ programok indítása:
A DOS unit lehetõséget biztosít arra, hogy programunkból más - az operációs rendszer által futtatható - programokat hívjunk meg. Ehhez az alábbi eljárásokra és függvényekre van szükségünk:

Exec eljárás:
Külsõ program futtatása. Szintaxisa: Exec(Programnev, Parameterek);
Programnev: String; - a futtatható állomány elérési útját, nevét és kiterjesztését tartalmazza.
Parameterek: String; - ha a külsõ programnak paramétereket szeretnénk átadni, azokat ebben a változóban kell elhelyezni.
Az eljárás EXE és COM kiterjesztésû programok futtatására alkalmas, a BAT kiterjesztésû kötegelt állományok indítása közvetlenül nem megoldható (egy trükk segítségével igen).

SwapVectors eljárás:
A megszakítási vektorok tartalmának elmentése. Szintaxisa: SwapVectors;
A SwapVectors eljárást célszerû meghíni az Exec eljárás alkalmazása elõtt és után, hogy a hívott és az általunk írt program megszakításai ne keveredjenek össze. Általában minden program használja a megszakításokat, ezért célszerû minden esetben alkalmazni ezt az eljárást, ha külsõ programot szeretnénk programunkból futtatni.

DosExitCode függvény:
Az utoljára hívott külsõ program visszatérési kódja. Szintaxisa: Kod:= DosExitCode;
A függvény visszatérési értéke alapján megtudhatjuk, hogy a program sikeresen fejezõdött-e be.
 

Megszakítások kezelése:
Ebbe a csoportba tartoznak azok az eljárások, függvények, amelyek az operációs rendszer és a BIOS alacsony szintû szolgáltatásainak igénybevételéhez szükségesek.

Intr eljárás:
Megszakítás hívása. Szintaxis: Intr(N, R);
N: Word - ezt a megszakítást fogja az eljárás aktivizálni.
R: Registers; - ez a paraméter a regiszterek aktuális értékét tartalmazza. Minden esetben változó kell legyen.
Magyarázat helyett álljon itt egy egyszerû példa a megszakítások használatára. Írjunk ki egy karaktert a képernyõre.

Uses DOS;
Var R: Registers;
Begin
    R.Ah:= $9;           
    R.Al:= Ord('A');   
    R.Bl:= $07;          
    Intr($10, R);         
End.

MsDos eljárás:
A $21 megszakítás hívása. Szintaxisa: MsDos(R);
R: Registers; - ez a paraméter a regiszterek aktuális értékét tartalmazza. Minden esetben változó kell legyen.
Az eljárás egyenértékû az Intr($21, R) eljárás hívásával. Mivel a $21 sorszámú megszakítás a DOS funkciókat aktivizálja, kiemelt szerepe van - ezeket használjuk leggyakrabban - ezért külön eljárást kapott a DOS unitban.
Egy példa az MsDos eljárás használatára: Kérdezzük le az operációs rendszer verziószámát. (Windows alatt is mûködik!)

Uses DOS;
Var R: Registers;
Begin
    R.Ax:= $3000;
    MsDos(R);      
    Writeln('Az operacios rendszer verzioszama: ', R.Al, '.', R.Ah);
End.