V těchto jednotkách se nacházejí nejčastěji používané funkce. Jednotka Turbo3
obsahuje příkazy jednotky System Turbo Pascalu 3.0 a je zde především kvůli
zpětné kompatibilitě. Jednotka Strings pak umožňuje práci s dlouhými (Null-terminated)
řetězci.
Tato jednotka se jako jediná neuvádí v uses. Obsahuje natolik běžné příkazy,
že její využití se předpokládá v každém Pascalském programu.
Proměnné jednotky System obsahují informace o spuštěném programu a aktivním
prostředí.
var
Input, Output: Text; {Standardní vstupní / výstupní soubory (klávesnice a obrazovka)}
InOutRes : integer; {Tato proměnná uchovává výsledek I/O operace, než je zavolána funkce IOResult}
ExitProc : pointer; {Ukazatel na ukončovací proceduru, (standardně nil),
potřebujeme-li vlastní ukončovací příkazy, vytvoříme proceduru a ukazatel
nastavíme na ni}
ExitCode : integer; {Kód ukončení programu}
ErrorAddr : pointer; {Nastavení správné chybové adresy (obsluha dané chyby např. při RunError)}
FileMode : byte; {Přístupový režim ke všem právě otevřeným souborů, viz Konstanty režimu přístupu}
FreeList : pointer; {Ukazatel pro práci s hromadou}
FreeZero : word; {Ukazatel pro práci s hromadou}
HeapEnd : pointer; {Ukazatel na konec (dno) hromady}
HeapError : pointer; {Ukazatel pro práci s hromadou}
HeapOrg : pointer; {Ukazatel na začátek hromady}
HeapPtr : pointer; {Ukazatel na aktuální položku v hromadě}
StackLimit : word; {Offset dna zásobníku = nejnižší hodnota SP, kdy ještě nedojde k přetečení,
normálně nulová, v případě {$N+,E+} je nastavena na 224}
Test8086 : byte; {Procesor - 0=I8086, 1=I80286 a 2=I8038 nebo novější}
Test8087 : byte; {Numerický koprocesor - 0=Nenalezen, 1=I8087, 2=I80287, 3=I80387 nebo novější}
RandSeed : longint; {Nastavení generátoru náhodných čísel (stejný hodnota = stejná náhodná čísla) }
PrefixSeg :word; {Adresa segmentu prefixu programu (viz manuál operačního systému)}
Seg0040 : word; {Adresa segmentu proměnných BIOSu}
SegA000 : word; {Adresa segmentu videopaměti}
SegB000 : word; {Adresa segmentu videopaměti}
SegB800 : word; {Adresa segmentu videopaměti}
SelectorInc : word; {Hodnota, kterou je třeba přičíst k ukazateli, aby ukazoval o 64KB dále, může se lišit od $100}
SaveIntnn : pointer; {Původní adresa nahrazených přerušení - Např. SaveInt1B je
adresa původní obsluhy přerušení 1B.}
Přehled měněných a ukládaných přerušení:
$0 |
$2 |
$1B |
$21 |
$23 |
$24 |
$34 |
$35 |
$36 |
$37 |
$38 |
$39 |
$3A |
$3B |
$3C |
$3D |
$3E |
$3F |
$75 |
|
Pro větší přehlednost dělíme podprogramy podle druhu vykonávané činnosti:
Přesnost výsledných funkcí se liší podle toho, zda je použit numerický
koprocesor (příp. jeho emulace). (Což můžeme ovlivnit direktivami
{$N} {$E}, případně přímým nastavením kompilátoru.)
Jsou-li instrukce numerického procesoru zapnuty, je výsledným typem Extended,
jinak pouze Real.
- Abs(x : TypeOfX) : TypeOfX; Absolutní hodnota X,
výsledek je stejného typu jako argument
- Sqr(x: Real) : Real; Druhá mocnina x
- Sqrt(x: Real) : Real; Druhá odmocnina z x
- Pi : Real; Hodnota Ludolfova čísla (Pí) =
3.1415...
- Sin(x : Real) : Real; Sin x - x je v radiánech
- Cos(x : Real) : Real; Cos x - x je v radiánech
- ArcTan(x : Real) : Real; Tan-1 - výsledek je udán v
radiánech
- Exp(x: Real) : Real; ex
- Ln(x: Real) : Real; ln x - přirozený logaritmus
z x
- Frac(x : Real) : Real; Desetinná část x
- Int(x : Real) : Real; Celá část x (přesto je
výsledkem reálné číslo)
Přestože mnohé z těchto funkcí lze nahradit (např. pomocí x:=x+1), je
výsledný kód získaný použitím zde uvedených procedur a funkcí o mnoho rychlejší.
- Dec(var x); Sníží x o
jedna
- Dec(var x; n : Longint);
Sníží x o n
- Inc(var x); Zvýší x o jedna
- Inc(var x; n : Longint); Zvýší x o n
- High(X); Vrátí nejvyšší možnou hodnotu dané
proměnné či typu, je-li X řetězec, vrátí jeho maximální délku, u pole jeho
maximální index
- Low(X); Vrátí nejnižší možnou hodnotu dané
proměnné či typu, je-li X řetězec, vrátí 0, u pole vrací jeho dolní index
- Odd(x : longint) : Boolean; Je-číslo liché?
- Pred(x : ordinal) : ordinal; Vrátí předchůdce dané
hodnoty (neprovádí žádné testování mezí). Pred(25) = 24
- Succ(x: ordinal) : ordinal; Vrátí následovníka dané
hodnoty (neprovádí testování mezí) Succ(13) = 14
- Concat(s1, s2, s3,...:string):string; Spojí
několik řetězců do jediného. Maximální délka výstupu je 255 znaků. (Tato
funkce lze kupodivu lze použít i na spojení jediného řetězce...)
- Copy(s:string; index, count : integer) : string;
Funkce vrátí podřetězec s1, který začíná index-tým znakem a který sám obsahuje
count znaků
- Delete(var x:string; index, count : integer);
Procedura vymaže daný úsek z řetězce (označení viz výše)
- Insert(src:string; var s:string; idx : integer);
Procedura vloží na idx-té místo řetězce s řetězec src
- Length(s:string) : integer; Skutečná délka
řetězce s
- Pos(substr:string;s:string) : integer; Vyhledá první výskyt
podřetězce substr v řetězci s, vrací index prvního písmene. Nenajde-li
podřetězec, vrací 0
- Str(x, var s:string); Převede číslo x na řetězec
(dovoluje použít i zápis X:m:dm udávající počet míst a počet desetinných míst
daného čísla)
- Val(s:string; var v; code : integer); Převede
řetězec (který musí vyhovovat konvenci - tedy žádné mezery, desetinná tečka
místo čárky,...) na číslo. code označuje index, u kterého došlo k chybě, při
úspěšném provedení je code=0.
- Chr(x : Byte) : char; Vrátí x-tý znak v ASCII
tabulce
- Ord(x) : Longint; Vrátí pořadové číslo prvku
- Round(x:Real) : longint; Zaokrouhlí reálné číslo,
výsledkem je číslo celé
- Trunc(x:Real) : longint; Převede reálné číslo na
celé tím, že "usekne" desetinnou část
- UpCase(c:char) : char; Převede malé písmeno na velké (ostatní znaky
nechá beze změny)
- Str(x, var s:string); Převede číslo x na řetězec
(dovoluje použít i zápis X:m:dm udávající počet míst a počet desetinných míst
daného čísla)
- Val(s:string; var v; code : integer); Převede
řetězec (který musí vyhovovat konvenci - tedy žádné mezery, desetinná tečka
místo čárky,...) na číslo. code označuje index, u kterého došlo k chybě, při
úspěšném provedení je code=0.
- Break; Procedura okamžitě ukončí právě probíhající
cyklus (for, while, či repeat). Jsou-li cykly vnořené, ukončí nejvnořenější
- Continue; Přejde na konec cyklu (a buď ho vykoná od
začátku, nebo skončí)
- Exit; Ukončí podprogram (=probíhající proceduru)
- Halt; Okamžitě ukončí program
- Halt(n); Ukončí program a jako výstupní hodnotu (ERRORLEVEL)
udá n
- RunError; Ukončí program tím, že vyvolá chybu 0.
- RunError(n); Ukončí program vyvoláním chyby s číslem n
(lze tak trápit uživatele např. hláškami typu disk C: nenalezen)
- New(var p:pointer); Vytvoří novou dynamickou
proměnnou a nastaví na ni ukazatel p
- Dispose(var p:pointer); Zruší dynamickou
proměnnou, na kterou ukazuje ukazatel p, do ukazatele pak vloží hodnotu nil
- New(var p:pointer,const:constructor); Vytvoří
nový dynamický objekt, nastaví naň ukazatel a spustí constructor objektu const
(např. New(p,Init) )
- Dispose(var p:pointer,dest:destructor); Zruší
dynamický objekt, zavolá jeho destruktor (dest) a vyniluje ukazatel
- MaxAvail : longint; Vrací maximální délku
souvislé paměti v hromadě (tedy nejvyšší možnou velikost dynamické proměnné)
- MemAvail : longint; Vrací velikost volné paměti v
hromadě (tedy velikost té paměti, které je ještě volná pro dynamické proměnné)
- GetMem(var p:pointer; size : word); Vytvoří novou
dynamickou proměnnou o velikosti Size bytů. Nejčastěji se používá spolu s
funkcí SizeOf : GetMem(p,SizeOf(DynamickaPromenna));
- FreeMem(var p:pointer; size : word); Zruší dynamickou
proměnnou vytvořenou pomocí GetMem
- Mark(P:Ukazatel); uloží stav hromady
(volné paměti) do ukazatele (nesmí být použito s GetMem a FreeMem)
- Release(P:Ukazatel); Obnoví stav hromady podle P
(kam byl uložen pomocí Mark...) - raději na příkladu :
- Assign(f:Soubor,DosovskyNazevExternihoSouboru); Přiřadí
proměnné soubor. Prázdný řetězec--> přiřadí soubor
Output či Input (Obrazovku či klávesnici)
- Reset(f:Soubor); Otevře soubor pro čtení (nastaví
pomyslný ukazatel na první položku souboru)
- Rewrite(f:Soubor); Otevře soubor pro zápis (smaže celý
soubor a nastaví ukazatel na začátek souboru)
- Append(f:Text); Otevře textový soubor pro přidání
(nastaví ukazatel na konec existujícího textového souboru)
- Close(f:Soubor); Zavře soubor (a případně také uloží
veškeré změny v souboru na disk)
- Eof(f:soubor) : Boolean; Funkce nabývá hodnoty true,
když je dosaženo konce souboru
- Eof : Boolean; takto použita udává, zda je dosaženo
konce souboru Input (data z klávesnice)
- SeekEof(f:soubor) : Boolean; Jako Eof, přeskakuje však
mezery, konce řádků a podobné znaky
- Eoln(f:Text):Boolean; Udává, zda je v textovém souboru
dosaženo konce řádky (znaky CR a LF)
- SeekEoln(f:Text):Boolean; Funguje stejně jako Eoln,
přeskočí však všechny mezery a tabelátory
- Flush(f:text); Zapíše dosud nezapsané znaky z Bufferu
na disk (normálně se zapisují až při zavolání Close, či je-li jich víc než
128)
- SetTextBuffer(var f:text, var buff[;size : word]); Změní velikost textového bufferu (zvětšení např.
sníží počet přístupů na disk)
- Write([f:soubor],v1,v2,...);
Vypíše do souboru f (či na obrazovku, není-li uveden), hodnoty v1, v2, které
jsou typu char, celočíselného, reálného, Boolean nebo string. Délku výpisu
hodnoty lze omezit pomocí v1:PocetMist, u reálných
typů ještě takto r:PocetMist:PocetDesetinnychMist;
- Writeln[([f:soubor],v1,v2,...)];Pracuje stejně jako Write, ale zapíše ještě
konec řádky, je-li volána bez parametrů, zapíše pouze konec řádky
- BlockRead(var f:file;var buf;count:word,[;result:word]);
čte hodnoty ze souboru bez udaného typu (přečte Count záznamů a uloží
je do buf - což je proměnná libovolného typu, result vrací počet skutečně
přečtených záznamů)
- BlockWrite(var f:file;var buf;count:word,[;result:word]);
Procedura zapíše jeden nebo více záznamů do souboru s neudaným typem. Pracuje
podobně jako BlockRead.
- FilePos(f:Soubor) : longint; Vrací současnou pozici v
souboru (na začátku nula, na konci FileSize(f);). Nelze použít na soubor typu
Text;
- FileSize(f:Soubor) : longint; Vrací celkový počet
komponent v souboru (nesmí být použita na soubor typu Text)
- Seek(f:Soubor, n : longint); Nastaví pozici v souboru
na n (nesmí být použita na soubor typu Text), Číslo první komponenty je 0,
poslední FileSize-1
- Truncate(f:Soubor); Vymaže všechny záznamy od aktuální
pozice až do konce. Po jejím provedení nabývá Eof hodnoty true.
- IOResult : word; Při {I-} vrátí kód poslední I/O
operace. Nastala-li chyba, jsou všechny příkazy mezi příkazem a IOResult
ignorovány.
- ChDir(s:string); Změní současný
adresář na s
- GetDir(d:byte;var s:string); Do s uloží cestu na
vybraném disku (d=0 aktuální disk, 1 - A:, 2 - B:, 3 - C: ,...);
- MkDir(s : string); V aktuálním umístění vytvoří adresář
se zadaným názvem
- RmDir(s : string); Smaže prázdný adresář zadaného jména
- Erase(var f:file); Smaže z disku neotevřený soubor
spojený s proměnnou f
- Rename(var f : file; newname:string); Přejmenuje
neotevřený soubor spjatý s f na newname
- Assigned(var P) : Boolean; Zjistí, zda daný
ukazatel někam ukazuje (stejně jako P<>nil)
- CSeg : word; Vrátí aktuální hodnotu registru CS (Code
Segment) -segment aktuálního kódu (spolu s offsetem nula ukazuje na začátek
spustitelného kódu)
- DSeg : word; Vrátí aktuální hodnotu registru DS (Data
Segment) - segment dat
- SSeg : word; Vrátí aktuální hodnotu registru SS (Stack
Segment) -segment zásobníku
- SPtr : word; Vrátí aktuální hodnotu registru SP (Stack
Pointer) - ukazatel na současnou pozici zásobníku
- Seg(x) : word; Vrátí adresu segmentu daného objektu.
Segment udává vzdálenost objektu od počátku paměti měřenou v 16-ti bytových
blocích
- Ofs(x) : word; Vrátí offset adresy dané proměnné.
Offset udává vzdálenost objektu od začátku segmentu měřenou v bytech
- Addr(x) : pointer; Vrátí celou adresu (tedy
ukazatel) na daný objekt. Stejné je i @
x.
- Ptr(sgm, oft : word) : pointer;
Vytvoří ze segmentu a ofsetu kompletní adresu (tedy ukazatel na daný
objekt)
Nejprve si krátce řekneme, co je to tabulka virtuálních metod objektu typu
object. Každý objekt obsahuje ukazatel na tuto tabulku. Tabulka mimo jiné
obsahuje ukazatele na jednotlivé virtuální procedury a funkce. V praxi to
znamená, že mají-li dva objekty stejný ukazatel, jsou stejného typu.
- Exclude(var S:set of T; I:T); Vyjme z množiny
prvek I (je-li tam); (Je o něco výhodnější než S:=S+[
I ];
- Include(var S:set of T; I:T); Přiřadí do množiny prvek
I (není-li tam již přítomný);
- Randomize; Nastaví generátor náhodných čísel na
náhodnou hodnotu
- Random : Real; Vrátí náhodné reálné číslo z
intervalu <0,1) (Pro vyšší
rozsah musíme něčím znásobit).
- Random(range : word):Word; Vrátí náhodné celé číslo z intervalu
<0, range)
- Swap(x : TypeOfX) : TypeOfX; Prohodí dolní a horní
byte argumentu (ten musí tedy mít dva byty, že... tedy integer nebo word)
- Hi(x) : word; Vrátí vyšší byt daného argumentu (který
je typu word, nebo integer);
- Lo(x) : word; Vrátí nižší byt daného argumentu
(které je typu word, nebo integer);
- SizeOf(x) : word; Vrátí počet bytů, které v paměti
potřebuje daný objekt
- FillChar(var X;count :Word;Value:ordinal); Vyplní
oblast paměti ordinální hodnotou Value, začne od X a zaplní Count bytů (
- Move(var source, dest; count:integer); Přesune
Count bytů z oblasti source do oblasti Dest (neprovádí se kontrola přetečení)
- ParamCount : word; Vrátí počet parametrů, se kterými
byl daný program v příkazové řádce spuštěn
- ParamStr(index:word) : string; Vrátí index-tý
parametr, se kterým byl program spuštěn
- TypeOf(P:objekt) : pointer; Vrátí ukazatel na
tabulku virtuálních metod typu object. (Např. if TypeOf(Neco)<>TypeOf(TBlbec)
then writeln('Objekt není typu Blbec'));
Tato jednotka umožní využívat staré příkazy Turbo Pascalu verze 3.0. Většina
příkazů se shoduje se současnými příkazy. Nepředpokládám, že byste ji kdykoliv
aktivně využili. Dostanete-li do rukou program verze 3.0, prostě na začátek
připište uses Turbo3; (popř. Graph3 viz Graph3).
Pokud vás příkazy staré verze 3.0 přesto zajímají, můžete si stáhnout
kompletní anglický manuál na
http://oldcomputers.dyndns.org/public/pub/rechner/epson/~fjkraan/comp/tp30/doc/
(jednotlivé kapitoly jsou ve formátu PDF, doporučuji nejprve stáhnou obsah)
Tato jednotka zavádí tzv. Null-terminated řetězce. Jedná se o řetězce jejichž
délka je omezena jen délkou spojitě volné paměti. Takovýto řetězec je ukončen
znakem konce řetězce (#0) z čehož vyplývá jediné
omezení tohoto typu řetězců - nesmí obsahovat znak #0.
Další nevýhodou takovéhoto přístupu je poměrně špatná manipulace s daným
řetězcem (např. pro zjištění délky řetězce se musí projít veškeré znaky
řetězce,...)
Tento typ řetězců je např. vyžadován všemi windowsáckými programy (Windowsácké
rozhraní API uznává jen tento typ řetězců).
Aby jednotka Strings mohla fungovat, je třeba zapnout rozšířenou syntaxi (buď
v menu nebo pomocí {$X+}). Většina příkazů této
jednotky jsou funkce, jelikož však většinou nepotřebujeme znát výstupní hodnotu,
můžeme je volat i jako procedury (volání funkce jako samostatného příkazu je
umožňuje právě rozšířená syntaxe - ale se standardním Pascalem to mnoho
společného nemá).
Jednotka strings zavádí nový typ řetězce : PChar. Jedná se vlastně o ukazatel
na znak. Všechny další znaky v paměti až do prvního výskytu
#0 se berou jako součást daného řetězce. Rozšířená syntaxe umožní do
PCharu přiřadit i obyčejný řetězec, či samotný znak. PChar si také můžeme
představit jako array[1..X] of Char; (problém ovšem
je, že to X neznáme, nicméně v paměti se tyto reprezentace shodují a s
rozšířenou syntaxí můžeme využívat obě dvě.)
- StrCopy(Dest,Source:PChar) :PChar; Zkopíruje Source do Dest (a
vrací Dest)
- StrPCopy(Dest:PChar, Source : string) :PChar; Zkopíruje Source do
Dest (a vrací Dest)
- StrLCopy(Dest,Source:PChar,L) :PChar; Zkopíruje Source do Dest
(kopíruje maximálně L znaků)
- StrCat(Dest,Source:PChar) :PChar; Připojí Source k Dest
- StrLCat(Dest,Source:PChar,L) :PChar; Připojí Source k Dest, ale
připojí max. L znaků
- StrLen(S:PChar):Word; Udává počet znaků v daném řetězci
- StrLower(S:PChar):PChar; Mění všechna velká písmena na malá.
- StrUpper(S:PChar):PChar; Mění všechna malá písmena na velká.
- StrPas(S:PChar) : string; Mění ASCIIZ řetězec na obyčejný string
(maximálně prvních 255 znaků)
- StrComp(s1,s2:PChar) : Integer; Porovná dva řetězce. Výsledek je 0,
jsou-li stejné. Záporné číslo, je-li s1 < s2 a číslo kladné znamená, že s1 >
s2
- StrIComp(s1,s2:PChar) : Integer; Pracuje stejně, ale nerozlišuje
velká a malá písmena
- StrLComp(s1,s2:PChar,L) : Integer; Pracuje stejně jako StrComp, ale
porovná pouze prvních L znaků.
- StrLIComp(s1,s2:PChar,L) : Integer; Stejně jako StrLComp porovná
první L znaků dvou řetězců. Nerozlišuje velká a malá písmena.
- StrECopy(Dest,Source:PChar):PChar; Zkopíruje Source do Dest,
ukazatel (typu PChar) nastaví na konec řetězce
- StrEnd(s1:PChar):PChar; ukazatel (typu PChar) na konec řetězce
- StrMove(Dest,Source:PChar,Count:Word):PChar; Zkopíruje Count znaků
ze Source do Dest a vrací Dest
- StrPos(s1,s2:PChar):PChar; vrací ukazatel (typu PChar) na první
výskyt s2 v řetězci s1. V případě, že se s2 v s1 nevyskytuje vrací nil.
- StrScan(s:PChar,ch:Char):PChar; vrací ukazatel (typu PChar) na
první výskyt znaku ch v řetězci s popř. nil. (Ukončovací znak je
součástí s)
- StrRScan(s:PChar,ch:Char):PChar; vrací ukazatel (typu PChar) na
poslední výskyt znaku ch v řetězci s popř. nil.
- StrNew(s:PChar):PChar; Zkopíruje s na nové místo v paměti a vrátí
na něj ukazatel (v případě, že je s = nil, nedělá nic)
- StrDispose(s:PChar); Odstraní z paměti řetězec vytvořený pomocí
StrNew;
Vyzkoušejte si např. StrECopy(StrECopy(StrECopy(s1,s2),s3),s4)); writeln(S1);
ať pochopíte, co přesně znamená, že řetězce PChar jsou ve skutečnosti ukazatele
(StrECopy nastaví výsledný ukazatel na konec řetězce).