Zpět na seznam článků     Číst komentáře (2)     Verze pro tisk

Pascal pro začátečníky 11 - Unita DOS

Autor: Kub@z   
13.4.2004

Úplný popis unity DOS najdete v nápovědě k překladači. Já se zde budu zabývat pouze nejzákladnějšími a nejpoužívanějšími procedurami a funkcemi. Pro zjištění volného místa na disku použijete funkci...


Úplný popis unity DOS najdete v nápovědě k překladači. Já se zde budu zabývat pouze nejzákladnějšími a nejpoužívanějšími procedurami a funkcemi. Pro zjištění volného místa na disku použijete funkci "DiskFree" a pro zjištění velikosti disku funkci "DiskSize". Parametr těchto funkcí tvoří číslo disku, kde se postupuje podle pravidla 1 = A, 2 = B, 3 = C atd. Pokud disk neexistuje, funkce vrátí -1. Takže když si budete chtít napsat prográmek, který vám vypíše všechny disky a jejich velikost, uděláte to takto:

uses dos;
const disky: string = 'ABCDEFGHIJKLMN'; (* to snad stačí :) *)
var size: longint;
   disk: byte;
begin
disk := 3; (* začneme u trojky, abychom přeskočili disketové mechaniky *)
repeat
size := DiskSize(disk);
if size = -1 then break;
writeln('Disk '+disky[disk]+ ' ma ', size div (1024*1024), ' MB');
disk := disk + 1;
until false;
end.

Háček je v tom, že longint má rozsah jenom něco přes 2 miliardy, takže nám to správně zjistí maximálně tak velikost CD nebo diskety. Další funkcí, která se může hodit je "DosVersion", která vrátí číslo verze DOSu. "EnvCount" vrací počet systémových "proměnných" a "EnvStr" vrací řetězec ve tvaru "jmeno=hodnota":

uses Dos;
var i: Integer;
begin
 for i := 1 to EnvCount do (* vypíšeme všechny systémové proměnné *)
  writeln(EnvStr(i));
end.

S tímto souvisí i funkce "GetEnv(jméno: string)", která vrací hodnotu proměnné uvedené v parametru:

uses dos;
begin
writeln('Pouzita command lajna: '+GetEnv('COMSPEC'));
writeln('Path: '+GetEnv('PATH'));
end.

Pro vyhledávání souborů jsou v unitě DOS zabudovány procedury "FindFirst" a "FindNext". Procedura "FindFirst" je deklarována takto:

procedure FindFirst(Path: String; Attr: Word; var F: SearchRec);

"Path" určuje cestu k souborům, "Attr" určuje atributy souboru, které se dají zapsat buď číselně, nebo pomocí konstant:

KonstantaHodnotaVýznam
  ReadOnly $01  Jen pro čtení
  Hidden $02  Skrytý
  SysFile $04  Systémový soubor
  VolumeID $08  Disk
  Directory $10  Složka
  Archive $20  Archivovat
  Anyfile $3F  Jakýkoliv soubor

"Searchrec" je definován takto:

type SearchRec = record
     Fill: array[1..21] of Byte;
     Attr: Byte;
     Time: Longint;
     Size: Longint;
     Name: string [12];
end;

Samozřejmě je definován v unitě DOS, takže si ho nemusíte definovat sám. A teď malé vysvětlení jednotlivých položek:

Fill - rezervováno pro DOS
Attr - atributy (podle tabulky)
Time - zapakované datum a čas poslední změny (jak ho rozpakovat se dozvíte v další části)
Size - velikost v bytech
Name - Jméno souboru i s příponou

Procedura "FindNext" je deklarována takto:

procedure FindNext(var F: SearchRec);

Tato hledá další výskyt souboru odpovídajícího podmínkám při hledání "FindFirst". Pokud není možné další soubor najít, vrátí funkce "DosError" jinou hodnotu než 0. Takže program který vypíše obsah C:\ je:

uses dos;
var soub: searchrec;
begin
FindFirst('c:\*.*',anyfile,soub); (* najdeme první soubor odpovídající zadání *)
while DosError = 0 do begin       (* dokud se soubor podaří najít *)
 writeln(soub.name, ' - ',soub.size, ' bytů'); (* vypíšeme jméno + velikost *)
 findnext(soub); (* najdeme další soubor *)
 end;
end.

A nyní slibované pakování a odpakování času a data. K tomu slouží procedury "PackTime" a "UnpackTime", které jsou deklarovány takto:

procedure PackTime(var T: DateTime; var Time: Longint);
procedure UnpackTime(Time: Longint; var DT: DateTime);

"DateTime" je deklarováno takto:

DateTime = record
 Year,Month,Day,Hour,Min,Sec: Word;
end;

Když tedy použijeme předchozí příklad, ale místo velikosti vypíšeme datum, tak to bude vypadat takto:

uses dos;
var soub: searchrec;
    d: datetime;
begin
FindFirst('c:\*.*',anyfile,soub);
while DosError = 0 do begin
 unpacktime(soub.time,d);
 writeln(soub.name,' - ',d.day,'.', d.month,'.', d.year,' ', d.hour,':', d.min,':', d.sec);
 findnext(soub);
 end;
end.

Pokud chcete zjistit datum a čas v OS, tak k tomu použijete procedury "GetDate" a "GetTime", které jsou deklarovány takto:

procedure GetDate(var Year, Month, Day, DayOfWeek: Word);
procedure GetTime(var Hour, Minute, Second, Sec100: Word);

Procedura "GetDate" je snad jasná, akorát se musím zmínit o tom, že "DayOfWeek" vrací číslo od 0 do 6, kde 0 je neděle. U procedury "GetTime" znamená "Sec100" setinu vteřiny. K nastavení data a času máme k dispozici procedury "SetDate" a "SetTime":

procedure SetDate(Year, Month, Day: Word);
procedure SetTime(Hour, Minute, Second, Sec100: Word);

Díky proceduře "GetTime" už máme možnost vytvořit si vlastní proceduru "Delay", která by čekala určitý počet setin vteřiny. Nevíte jak na to? Je to prosté. Vytvoříme si proměnnou "min", do které přiřadíme čas, kdy naše procedura delay začíná a proměnnou "souc", do které přiřadíme při každém proběhnutí cyklu aktuální čas. Cyklus pak bude probíhat do té doby, než bude aktuální čas větší než čas konce což je "min+doba" nebo je aktuální čas menší než původní doba. To proto, že když se jakoby dostaneme ke konci minuty, budou zase vteřiny "menší", a cyklus by mohl trvat třeba i minutu, i když v zadání bylo třeba jen 5 setin. Zní to sice složitě, ale tak složité to není:

uses dos;

procedure mydelay(stn: integer);
var n,vt,st: word;
    min,souc: longint;
begin
gettime(n,n,vt,st);
min := vt*100+st; (* zjistíme čas, kdy procedura začala *)
repeat
gettime(n,n,vt,st);
souc := vt*100+st; (* vypočítáme aktuální čas *)
until (souc >= min + stn) or (souc < min);
     (* dokud nedosáhneme požadovaného času *)
end;

begin
write('Text');
mydelay(50);
write('Text vypsany po polovine vteriny');
end.

Pokud to nechápete, tak se musíte smířit s tím, že to funguje :). Tato procedura by se dala jednoduše přepsat také s pomocí "PackTime" a "UnpackTime", ale já jsem ji pro zjednodušení zapsal takhle. Procedury sloužící ke zjištění data a času změny souboru a atributů souboru jsou "GetFTime" a "GetFattr". Tyto procedury nám zjistí informace o souboru vyjádřeném typem "file" a jsou deklarovány takto:

procedure GetFTime(var F; var Time: Longint);
procedure GetFAttr(var F; var Attr: Word);

Tento soubor "F" musí být otevřený příkazem "reset". Naopak k nastavení těchto věcí slouží:

procedure SetFTime(var F; Time: Longint);
procedure SetFAttr(var F; Attr: Word);

Příklad:

uses dos;
var f: file; (* file může být i beztypový *)
    pom: longint;
    d: datetime;
begin
assign(f,'pok.hmm'); (* na příponě nezáleží *)
rewrite(f); (* vytvoříme soubor *)
getFTime(f, pom);
unpacktime(pom, d); (* tím jsme vlastně zjistili aktuální datum, *)
(* protože jsme ten soubor právě vytvořili *)
writeln(d.day,'.', d.month,'.', d.year); (* vypíšeme základní údaje *)
end.

To je prozatím z unity DOS vše, protože další funkce už souvisí s Assemblerem a já předpokládám, že pokud čtete tento návod, tak Assembler neznáte, a proto se jimi nebudu zabývat.

Kub@z

Líbil se Vám článek?
Budeme potěšeni, pokud vás zaujme také reklamní nabídka

Social Bookmarking

     





Hodnocení/Hlasovalo: 1.25/4

1  2  3  4  5    
(známkování jako ve škole)