HighSpeed Pascal (HiSoft, vývoj dánská firma D-House, konec 80. let) je kompilátor Pascalu pro Atari ST, který jazykem úmyslně kopíruje Turbo Pascal 4.0/5.0 z PC. Programy se překládají přímo do strojového kódu 68000, prostředí obsahuje editor a velmi rychlý kompilátor a kód se dělí do unitů stejně jako v Turbo Pascalu. Většina učebnic a zdrojáků pro Turbo Pascal 5 se tak dá použít téměř beze změn.
◆ Ověřte ve své verzi: jazyk a standardní rutiny v této příručce odpovídají Turbo Pascalu 5. Atari specifické části (názvy unitů pro GEM, přesné typy parametrů, některé direktivy) se mezi verzemi a edicemi liší. Jsou označené symbolem ◆ a před použitím je porovnejte s rozhraním unitů na vaší disketě nebo v manuálu.
Prostředí
V monochromním rozlišení High (640×400) má textová obrazovka 80×25 znaků; grafika přes VDI pracuje v souřadnicích 0..639 × 0..399. Program spuštěný z GEM desktopu jako .TOS nebo .TTP po skončení okamžitě zmizí, proto končete textové programy příkazem ReadLn, dokud ladíte. Programy, které otevírají GEM okna nebo dialogy, se ukládají s příponou .PRG.
Atari ST používá vlastní znakovou sadu, ve které nejsou česká písmena s háčky a čárkami. Ve zdrojových kódech níže proto řetězce i komentáře záměrně píšu bez diakritiky.
První program
program Ahoj;
begin
WriteLn('Ahoj, Atari ST!');
WriteLn('Stiskni Return...');
ReadLn;
end.Deklarační části (uses, label, const, type, var, podprogramy) mohou jít v libovolném pořadí a opakovat se, pokud je každý identifikátor deklarovaný dřív, než se použije. Hlavní program je blok begin … end. s tečkou na konci.
program Struktura;
uses Crt;
const
MaxBodu = 10;
Titulek = 'Body v rovine';
type
TBod = record
X, Y: Integer;
end;
TBody = array[1..MaxBodu] of TBod;
var
Body: TBody;
i: Integer;
procedure Vypis(B: TBod);
begin
WriteLn('(', B.X:4, ',', B.Y:4, ')');
end;
begin
ClrScr;
WriteLn(Titulek);
for i := 1 to MaxBodu do
begin
Body[i].X := i * 10;
Body[i].Y := i * i;
Vypis(Body[i]);
end;
ReadLn;
end.Komentáře se píší do { … } nebo (* … *). Komentář začínající znakem $, například {$I-}, je direktiva kompilátoru. Velikost písmen v identifikátorech nehraje roli.
| Typ | Rozsah / popis | Velikost |
|---|---|---|
ShortInt | −128 .. 127 | 1 B |
Byte | 0 .. 255 | 1 B |
Integer | −32 768 .. 32 767 | 2 B |
Word | 0 .. 65 535 | 2 B |
LongInt | −2 147 483 648 .. 2 147 483 647 | 4 B |
Real | reálné číslo; přesnost a rozsah závisí na implementaci ◆ | dle verze |
Boolean | False, True | 1 B |
Char | jeden znak (kód 0..255) | 1 B |
String | řetězec do 255 znaků; String[n] do n znaků | n + 1 B |
Pointer | netypový ukazatel; ^T typový | 4 B |
Text | textový soubor | — |
Uživatelské typy
type
TDen = (Po, Ut, St, Ct, Pa, So, Ne); { vyctovy typ }
TPracDen = Po..Pa; { interval }
TZnaky = set of Char; { mnozina }
TMatice = array[1..3, 1..3] of Real; { 2D pole }
TJmeno = String[30];
TOsoba = record
Jmeno: TJmeno;
Vek: Byte;
Plat: LongInt;
end;
PUzel = ^TUzel; { ukazatel smi predchazet }
TUzel = record
Hodnota: Integer;
Dalsi: PUzel;
end;
var
Samohlasky: TZnaky;
Den: TDen;
begin
Samohlasky := ['A', 'E', 'I', 'O', 'U', 'Y'];
Den := St;
WriteLn(Ord(Den)); { 2 }
if 'E' in Samohlasky then WriteLn('je samohlaska');
end.Typované konstanty a přetypování
Typovaná konstanta je ve skutečnosti inicializovaná proměnná. Přetypování se zapisuje jménem typu jako funkcí.
const
Dny: array[1..7] of String[3] = ('Po','Ut','St','Ct','Pa','So','Ne');
Pocitadlo: Integer = 0;
var
w: Word;
c: Char;
begin
w := Word(-1); { 65535 }
c := Char(65); { 'A', totez co Chr(65) }
Inc(Pocitadlo);
WriteLn(Dny[3], ' ', w, ' ', c, ' ', Pocitadlo);
end.Priorita od nejvyšší k nejnižší. Pozor: and a or mají vyšší prioritu než relační operátory, proto podmínky v logických výrazech vždy závorkujte: (a > 0) and (b > 0).
| Priorita | Operátory | Význam |
|---|---|---|
| 1 | not @ | negace, adresa |
| 2 | * / div mod and shl shr | násobení, reálné dělení, celočíselné dělení, zbytek, logický/bitový součin, posuny |
| 3 | + - or xor | sčítání, odčítání, sjednocení řetězců, logický/bitový součet |
| 4 | = <> < > <= >= in | porovnání, příslušnost do množiny |
Operátor / vrací vždy reálné číslo, i když dělíte dvě celá čísla. Pro celočíselný výsledek použijte div. U množin znamená + sjednocení, * průnik a - rozdíl.
program Rizeni;
var
i, n, soucet: Integer;
znak: Char;
begin
{ if - pred else NIKDY nepiste strednik }
n := 7;
if n mod 2 = 0 then
WriteLn('sude')
else
WriteLn('liche');
{ case - vetve mohou byt hodnoty, seznamy i intervaly }
znak := 'k';
case znak of
'a'..'z': WriteLn('male pismeno');
'A'..'Z': WriteLn('velke pismeno');
'0'..'9': WriteLn('cislice');
else
WriteLn('jiny znak');
end;
{ for - ridici promenna musi byt ordinalni }
soucet := 0;
for i := 1 to 10 do soucet := soucet + i;
for i := 10 downto 1 do Write(i, ' ');
WriteLn;
{ while - test pred pruchodem }
i := 1;
while i < 1000 do i := i * 2;
WriteLn('prvni mocnina 2 nad 1000: ', i);
{ repeat - test po pruchodu, provede se aspon jednou }
repeat
Write('Zadej kladne cislo: ');
ReadLn(n);
until n > 0;
WriteLn('Soucet 1..10 = ', soucet);
end.Exit ukončí aktuální podprogram, Halt celý program (volitelně s návratovým kódem). goto existuje, ale cíl musí být deklarovaný v části label a ležet ve stejném bloku.
Parametr předaný hodnotou je kopie; parametr s var je odkaz a podprogram může měnit původní proměnnou. Velká pole a záznamy předávejte přes var i tehdy, když je neměníte, ušetříte kopírování a zásobník. Výsledek funkce se nastavuje přiřazením do jména funkce.
program Podprogramy;
procedure Prohod(var a, b: Integer);
var t: Integer;
begin
t := a; a := b; b := t;
end;
function Faktorial(n: Integer): LongInt;
begin
if n <= 1 then
Faktorial := 1
else
Faktorial := n * Faktorial(n - 1); { rekurze }
end;
function NSD(a, b: LongInt): LongInt; { Eukliduv algoritmus }
var t: LongInt;
begin
while b <> 0 do
begin
t := a mod b;
a := b;
b := t;
end;
NSD := a;
end;
{ dopredna deklarace pro vzajemnou rekurzi }
function JeLiche(n: Integer): Boolean; forward;
function JeSude(n: Integer): Boolean;
begin
if n = 0 then JeSude := True else JeSude := JeLiche(n - 1);
end;
function JeLiche(n: Integer): Boolean;
begin
if n = 0 then JeLiche := False else JeLiche := JeSude(n - 1);
end;
var x, y: Integer;
begin
x := 3; y := 8;
Prohod(x, y);
WriteLn(x, ' ', y); { 8 3 }
WriteLn('10! = ', Faktorial(10));
WriteLn('NSD(84, 36) = ', NSD(84, 36));
WriteLn('JeSude(7) = ', JeSude(7));
ReadLn;
end.Vnořené podprogramy a procedurální typy
Podprogram může obsahovat vlastní lokální podprogramy, které vidí proměnné nadřazeného. Procedurální typy (např. type TFce = function(x: Real): Real;) fungují jako v Turbo Pascalu 5; funkce předávaná jako hodnota musí být překládaná se vzdáleným voláním, v Turbo Pascalu direktivou {$F+} ◆.
Typ String je pole znaků s délkou uloženou v bajtu s[0]. Ke znakům se přistupuje indexem od 1. Řetězce se spojují operátorem +; výsledek delší než deklarovaná kapacita se tiše ořízne.
| Rutina | Popis | Příklad |
|---|---|---|
Length(s) | délka řetězce | Length('Atari') = 5 |
Copy(s, i, n) | podřetězec od pozice i, n znaků | Copy('Atari ST', 7, 2) = 'ST' |
Pos(sub, s) | pozice prvního výskytu, jinak 0 | Pos('ST', 'Atari ST') = 7 |
Insert(sub, s, i) | vloží sub do s na pozici i | procedura, mění s |
Delete(s, i, n) | smaže n znaků od pozice i | procedura, mění s |
Concat(s1, s2, …) | spojení řetězců | totéž jako s1 + s2 |
Str(x:w:d, s) | číslo na řetězec s formátem | Str(3.14159:0:2, s) → '3.14' |
Val(s, x, kod) | řetězec na číslo; kod = 0 při úspěchu, jinak pozice chyby | Val('123', n, k) |
UpCase(c) | velké písmeno (jen pro Char) | UpCase('a') = 'A' |
Chr(n), Ord(c) | převod kód ↔ znak | Ord('A') = 65 |
program Retezce;
var
s, slovo: String;
i, kod, cislo: Integer;
function Velka(s: String): String;
var i: Integer;
begin
for i := 1 to Length(s) do s[i] := UpCase(s[i]);
Velka := s;
end;
function Orez(s: String): String;
begin
while (Length(s) > 0) and (s[1] = ' ') do Delete(s, 1, 1);
while (Length(s) > 0) and (s[Length(s)] = ' ') do Delete(s, Length(s), 1);
Orez := s;
end;
begin
s := ' highspeed pascal ';
s := Velka(Orez(s));
WriteLn('[', s, ']'); { [HIGHSPEED PASCAL] }
i := Pos(' ', s);
slovo := Copy(s, 1, i - 1);
WriteLn('Prvni slovo: ', slovo);
Val('1040', cislo, kod);
if kod = 0 then WriteLn('Cislo + 1 = ', cislo + 1)
else WriteLn('Chyba na pozici ', kod);
ReadLn;
end.Soubor se nejdřív spojí se jménem přes Assign, pak otevře (Reset pro čtení, Rewrite pro nový zápis, Append pro připojení k textu) a nakonec zavře Close. Jména souborů na TOS jsou ve formátu 8.3 a cesty používají zpětné lomítko: 'A:\DATA\ADRESY.DAT'.
Textové soubory a kontrola chyb
Ve výchozím stavu chyba vstupu/výstupu ukončí program. S direktivou {$I-} se chyba jen zaznamená a vy ji přečtete funkcí IOResult (po přečtení se vynuluje).
program TextSoubor;
var
f: Text;
radek: String;
pocet: Integer;
begin
Assign(f, 'POZNAMKY.TXT');
Rewrite(f);
WriteLn(f, 'Prvni radek');
WriteLn(f, 'Druhy radek');
WriteLn(f, 'Cislo: ', 42);
Close(f);
Assign(f, 'POZNAMKY.TXT');
{$I-}
Reset(f);
{$I+}
if IOResult <> 0 then
begin
WriteLn('Soubor nelze otevrit.');
Halt(1);
end;
pocet := 0;
while not Eof(f) do
begin
ReadLn(f, radek);
Inc(pocet);
WriteLn(pocet:3, ': ', radek);
end;
Close(f);
ReadLn;
end.Typové soubory
Soubor file of T obsahuje záznamy stejné velikosti a dovoluje přímý přístup: Seek(f, n) skočí na záznam n (od nuly), FileSize(f) vrátí počet záznamů a FilePos(f) aktuální pozici. Celý příklad najdete v části Ukázkové programy.
Netypové soubory
file bez typu slouží ke kopírování binárních dat po blocích přes BlockRead a BlockWrite.
program Kopie;
var
zdroj, cil: file;
buf: array[1..4096] of Byte;
precteno, zapsano: Word;
begin
Assign(zdroj, 'A:\PUVODNI.DAT');
Reset(zdroj, 1); { velikost zaznamu 1 bajt }
Assign(cil, 'A:\KOPIE.DAT');
Rewrite(cil, 1);
repeat
BlockRead(zdroj, buf, SizeOf(buf), precteno);
BlockWrite(cil, buf, precteno, zapsano);
until (precteno = 0) or (zapsano <> precteno);
Close(zdroj);
Close(cil);
WriteLn('Hotovo.');
end.New(p) alokuje místo pro typ, na který ukazatel ukazuje, Dispose(p) ho uvolní. GetMem a FreeMem pracují s libovolným počtem bajtů. Hodnota na adrese se zpřístupní operátorem ^, prázdný ukazatel je nil. MemAvail vrací celkovou volnou paměť haldy, MaxAvail největší souvislý blok.
program SpojovySeznam;
type
PUzel = ^TUzel;
TUzel = record
Hodnota: Integer;
Dalsi: PUzel;
end;
var
Hlava, p: PUzel;
i: Integer;
procedure VlozNaZacatek(var H: PUzel; v: Integer);
var n: PUzel;
begin
New(n);
n^.Hodnota := v;
n^.Dalsi := H;
H := n;
end;
procedure UvolniVse(var H: PUzel);
var n: PUzel;
begin
while H <> nil do
begin
n := H^.Dalsi;
Dispose(H);
H := n;
end;
end;
begin
WriteLn('Volna pamet: ', MemAvail, ' B');
Hlava := nil;
for i := 1 to 5 do VlozNaZacatek(Hlava, i * i);
p := Hlava;
while p <> nil do
begin
Write(p^.Hodnota, ' '); { 25 16 9 4 1 }
p := p^.Dalsi;
end;
WriteLn;
UvolniVse(Hlava);
WriteLn('Volna pamet: ', MemAvail, ' B');
ReadLn;
end.Unit je samostatně překládaný modul. Část interface obsahuje to, co uvidí ostatní programy, implementation těla podprogramů a skryté deklarace. Volitelný blok begin … end. na konci unitu se spustí jednou při startu programu. Jméno souboru musí odpovídat jménu unitu.
unit Matika;
interface
function Mocnina(zaklad: Real; exponent: Integer): Real;
function JePrvocislo(n: LongInt): Boolean;
implementation
function Mocnina(zaklad: Real; exponent: Integer): Real;
var i: Integer;
v: Real;
begin
v := 1;
for i := 1 to Abs(exponent) do v := v * zaklad;
if exponent < 0 then v := 1 / v;
Mocnina := v;
end;
function JePrvocislo(n: LongInt): Boolean;
var d: LongInt;
begin
JePrvocislo := False;
if n < 2 then Exit;
d := 2;
while d * d <= n do
begin
if n mod d = 0 then Exit;
Inc(d);
end;
JePrvocislo := True;
end;
end.program TestMatiky;
uses Matika;
var i: Integer;
begin
WriteLn('2^10 = ', Mocnina(2, 10):0:0);
for i := 1 to 50 do
if JePrvocislo(i) then Write(i, ' ');
WriteLn;
ReadLn;
end.Unit nejdřív přeložte samostatně, kompilátor vytvoří přeložený soubor unitu ◆ (přípona podle verze), a pak teprve program, který ho používá. Kruhové odkazy mezi unity v části interface nejsou povolené; v implementation ano.
Unit Crt ovládá textovou obrazovku a klávesnici. Souřadnice začínají v levém horním rohu na (1, 1). Na monochromním monitoru nemají barevné rutiny viditelný efekt; inverzní text je otázkou verze unitu ◆.
| Rutina | Popis |
|---|---|
ClrScr | smaže obrazovku a nastaví kurzor do levého horního rohu |
ClrEol | smaže řádek od kurzoru do konce |
GotoXY(x, y) | přesune kurzor na sloupec x, řádek y |
WhereX, WhereY | aktuální pozice kurzoru |
KeyPressed | True, pokud čeká stisknutá klávesa (nečeká na ni) |
ReadKey | přečte znak bez ozvěny; u speciálních kláves vrací nejdřív #0 a pak kód ◆ |
Delay(ms) | pauza v milisekundách |
program Menu;
uses Crt;
var
volba: Char;
konec: Boolean;
procedure Ramecek(x1, y1, x2, y2: Integer);
var i: Integer;
begin
for i := x1 to x2 do
begin
GotoXY(i, y1); Write('-');
GotoXY(i, y2); Write('-');
end;
for i := y1 to y2 do
begin
GotoXY(x1, i); Write('|');
GotoXY(x2, i); Write('|');
end;
end;
begin
konec := False;
repeat
ClrScr;
Ramecek(25, 6, 55, 14);
GotoXY(30, 8); Write('1 Pozdrav');
GotoXY(30, 9); Write('2 Odpocet');
GotoXY(30, 11); Write('Q Konec');
GotoXY(30, 13); Write('Volba: ');
volba := UpCase(ReadKey);
case volba of
'1': begin
GotoXY(30, 16); Write('Ahoj!');
Delay(1000);
end;
'2': begin
GotoXY(30, 16);
for volba := '9' downto '0' do
begin
Write(volba, ' ');
Delay(300);
end;
end;
'Q': konec := True;
end;
until konec;
ClrScr;
end.Unit Dos zpřístupňuje služby operačního systému v rozhraní kompatibilním s Turbo Pascalem; na Atari ST je pod ním GEMDOS. Výsledek poslední operace je v proměnné DosError (0 = bez chyby).
| Rutina | Popis |
|---|---|
GetDate(r, m, d, dvt) | systémové datum; všechny parametry jsou Word |
GetTime(h, m, s, s100) | systémový čas (Word) |
FindFirst(maska, atr, sr) | první soubor odpovídající masce do záznamu SearchRec |
FindNext(sr) | další soubor |
DiskFree(disk) | volné místo v bajtech; 0 = aktuální, 1 = A:, 2 = B: … |
DiskSize(disk) | celková kapacita disku |
Exec(prog, param) | spustí jiný program ◆ |
Konstanty atributů: ReadOnly, Hidden, SysFile, VolumeID, Directory, Archive, AnyFile.
program VypisAdresare;
uses Dos;
var
sr: SearchRec;
r, m, d, dvt: Word;
celkem: LongInt;
pocet: Integer;
begin
GetDate(r, m, d, dvt);
WriteLn('Datum: ', d, '.', m, '.', r);
WriteLn;
celkem := 0;
pocet := 0;
FindFirst('*.*', AnyFile, sr);
while DosError = 0 do
begin
if (sr.Attr and Directory) <> 0 then
WriteLn(sr.Name:14, ' <DIR>')
else
begin
WriteLn(sr.Name:14, sr.Size:10);
celkem := celkem + sr.Size;
Inc(pocet);
end;
FindNext(sr);
end;
WriteLn;
WriteLn(pocet, ' souboru, ', celkem, ' B');
WriteLn('Volno: ', DiskFree(0), ' B');
ReadLn;
end.◆ Celá tato část: názvy GEM unitů a přesné typy parametrů se liší podle verze. Rutiny kopírují jména z C knihoven (Digital Research), takže appl_init, form_alert, v_gtext atd. odpovídají dokumentaci GEM. Typy polí pro v_opnvwk a seznam unitů v klauzuli uses (někdy je potřeba i unit s deklaracemi typů) převezměte z rozhraní unitů ve vaší instalaci.
GEM má dvě vrstvy. AES (Application Environment Services) obstarává okna, menu, dialogy a události. VDI (Virtual Device Interface) kreslí: čáry, výplně, text. Typický program se přihlásí k AES, získá od něj fyzický grafický handle, otevře nad ním virtuální VDI pracovní stanici, kreslí, a na konci vše v opačném pořadí zavře.
Nejdůležitější volání
| Volání | Vrstva | Popis |
|---|---|---|
appl_init | AES | přihlášení aplikace, vrací ap_id (−1 = chyba) |
appl_exit | AES | odhlášení před koncem programu |
graf_handle(…) | AES | handle fyzické stanice a rozměry systémového písma |
graf_mouse(tvar, nil) | AES | tvar kurzoru myši (šipka, přesýpací hodiny, skrytí) |
form_alert(def, text) | AES | alert box; vrací číslo stisknutého tlačítka |
evnt_keybd | AES | čeká na stisk klávesy |
v_opnvwk(in, h, out) | VDI | otevře virtuální pracovní stanici |
v_clsvwk(h) | VDI | zavře ji |
v_clrwk(h) | VDI | smaže obrazovku |
v_pline(h, n, pxy) | VDI | lomená čára přes n bodů |
v_gtext(h, x, y, s) | VDI | grafický text |
v_circle(h, x, y, r) | VDI | vyplněný kruh |
vsf_interior(h, styl) | VDI | styl výplně (prázdná, plná, vzorek) |
Formát alert boxu
Řetězec má tvar '[ikona][text][tlačítka]'. Ikona: 0 žádná, 1 vykřičník, 2 otazník, 3 stopka. Řádky textu i tlačítka se oddělují znakem |; text má nejvýš 5 řádků po 30 znacích, tlačítka nejvýš 3. První parametr určuje výchozí tlačítko (aktivované Returnem).
program GemDemo;
uses GemAES, GemVDI; { nazvy unitu overte ve sve verzi }
var
apId, vdiH, dummy, volba, i: Integer;
workIn: array[0..10] of Integer; { ◆ verze muze vyzadovat vlastni typ }
workOut: array[0..56] of Integer;
pxy: array[0..3] of Integer;
begin
apId := appl_init;
if apId < 0 then Halt;
volba := form_alert(1,
'[2][HighSpeed Pascal|GEM ukazka||Nakreslit obrazec?][ Ano | Ne ]');
if volba = 1 then
begin
{ virtualni VDI stanice nad fyzickym handle obrazovky }
vdiH := graf_handle(dummy, dummy, dummy, dummy);
for i := 0 to 9 do workIn[i] := 1;
workIn[10] := 2; { souradnice v rastrovych bodech }
v_opnvwk(workIn, vdiH, workOut);
{ workOut[0] + 1 = sirka, workOut[1] + 1 = vyska obrazovky }
graf_mouse(256, nil); { M_OFF - skryt mys pri kresleni }
v_clrwk(vdiH);
{ vejir car ze stredu obrazovky 640x400 }
for i := 0 to 32 do
begin
pxy[0] := 320; pxy[1] := 200;
pxy[2] := i * 20; pxy[3] := 0;
v_pline(vdiH, 2, pxy);
pxy[3] := 399;
v_pline(vdiH, 2, pxy);
end;
v_circle(vdiH, 320, 200, 60);
v_gtext(vdiH, 250, 290, 'HighSpeed Pascal');
graf_mouse(257, nil); { M_ON }
volba := form_alert(1, '[1][Hotovo.][ Konec ]');
v_clsvwk(vdiH);
end;
appl_exit;
end.Po skončení kreslení přímo na obrazovku GEM desktop sám nepřekreslí plochu; v plnohodnotné aplikaci se proto kreslí do vlastního okna (wind_create, wind_open) a obsah se obnovuje na událost WM_REDRAW. Pro první pokusy stačí výše uvedený postup a desktop překreslí klik do volného místa.
Direktivy se píší do komentáře se znakem $. Přepínač + zapne, - vypne. Uvedené jsou ty, které Turbo Pascal 5 používá a HighSpeed Pascal je přebírá; konkrétní sadu a výchozí hodnoty ověřte ve své verzi ◆.
| Direktiva | Význam |
|---|---|
{$I+} / {$I-} | kontrola V/V chyb; s - čtete chybu přes IOResult |
{$I JMENO.INC} | vloží obsah souboru do zdrojáku na tomto místě |
{$R+} / {$R-} | kontrola mezí polí a intervalů; při ladění zapínejte |
{$S+} / {$S-} | kontrola přetečení zásobníku |
{$B+} / {$B-} | úplné / zkrácené vyhodnocování logických výrazů |
{$V+} / {$V-} | přísná kontrola délky řetězců u parametrů var |
{$R+,S+} { pri ladeni }
program Ladeni;
{$I KONSTANTY.INC} { sdilene deklarace }
begin
{ ... }
end.Rutiny z unitu System, který je dostupný vždy bez uvedení v uses.
Aritmetika
| Rutina | Popis |
|---|---|
Abs(x) | absolutní hodnota |
Sqr(x), Sqrt(x) | druhá mocnina, druhá odmocnina |
Sin(x), Cos(x), ArcTan(x) | goniometrické funkce, úhel v radiánech |
Exp(x), Ln(x) | ex, přirozený logaritmus |
Pi | 3,14159… |
Int(x), Frac(x) | celá a desetinná část (reálný výsledek) |
Trunc(x), Round(x) | oříznutí, zaokrouhlení na LongInt |
Random, Random(n) | náhodné reálné 0 ≤ x < 1, celé 0 ≤ x < n |
Randomize | inicializace generátoru náhodných čísel |
Odd(n) | True pro liché číslo |
Ordinální typy
| Rutina | Popis |
|---|---|
Ord(x) | pořadové číslo hodnoty |
Chr(n) | znak s kódem n |
Succ(x), Pred(x) | následník, předchůdce |
Inc(x), Inc(x, n) | zvýší proměnnou o 1 nebo n |
Dec(x), Dec(x, n) | sníží proměnnou o 1 nebo n |
Lo(w), Hi(w) | nižší a vyšší bajt slova |
Swap(w) | prohodí bajty slova |
Paměť a systém
| Rutina | Popis |
|---|---|
New(p), Dispose(p) | alokace a uvolnění typového ukazatele |
GetMem(p, n), FreeMem(p, n) | alokace a uvolnění n bajtů |
MemAvail, MaxAvail | volná paměť celkem, největší souvislý blok |
SizeOf(x) | velikost proměnné nebo typu v bajtech |
FillChar(x, n, hodnota) | vyplní n bajtů proměnné hodnotou |
Move(zdroj, cil, n) | zkopíruje n bajtů |
Addr(x), @x | adresa proměnné |
ParamCount, ParamStr(i) | parametry příkazové řádky (programy .TTP) |
Exit, Halt(kod) | konec podprogramu, konec programu |
Vstup a výstup
| Rutina | Popis |
|---|---|
Write, WriteLn | výstup; formát x:šířka a u reálných x:šířka:desetiny |
Read, ReadLn | vstup z klávesnice nebo souboru |
Assign(f, jmeno) | spojí proměnnou souboru se jménem |
Reset, Rewrite, Append | otevření pro čtení, nový zápis, připojení |
Close(f) | zavření |
Eof(f), Eoln(f) | konec souboru, konec řádku |
Seek(f, n), FilePos(f), FileSize(f) | přímý přístup u typových souborů |
BlockRead, BlockWrite | blokové čtení a zápis netypových souborů |
Erase(f), Rename(f, nove) | smazání a přejmenování (soubor nesmí být otevřený) |
IOResult | kód poslední V/V chyby při {$I-} |
MkDir, RmDir, ChDir, GetDir | práce s adresáři |
Eratosthenovo síto
Prvočísla do 10 000 pomocí pole logických hodnot.
program Sito;
const
Max = 10000;
var
slozene: array[2..Max] of Boolean;
i, j, pocet: Integer;
begin
FillChar(slozene, SizeOf(slozene), 0); { vse False }
i := 2;
while i * i <= Max do
begin
if not slozene[i] then
begin
j := i * i;
while j <= Max do
begin
slozene[j] := True;
j := j + i;
end;
end;
Inc(i);
end;
pocet := 0;
for i := 2 to Max do
if not slozene[i] then
begin
Inc(pocet);
if pocet <= 30 then Write(i, ' ');
end;
WriteLn;
WriteLn('Prvocisel do ', Max, ': ', pocet); { 1229 }
ReadLn;
end.Quicksort
program Razeni;
const
N = 20;
type
TPole = array[1..N] of Integer;
var
a: TPole;
i: Integer;
procedure QuickSort(var a: TPole; l, r: Integer);
var
i, j, pivot, t: Integer;
begin
i := l; j := r;
pivot := a[(l + r) div 2];
repeat
while a[i] < pivot do Inc(i);
while a[j] > pivot do Dec(j);
if i <= j then
begin
t := a[i]; a[i] := a[j]; a[j] := t;
Inc(i); Dec(j);
end;
until i > j;
if l < j then QuickSort(a, l, j);
if i < r then QuickSort(a, i, r);
end;
procedure Vypis(var a: TPole);
var i: Integer;
begin
for i := 1 to N do Write(a[i]:4);
WriteLn;
end;
begin
Randomize;
for i := 1 to N do a[i] := Random(1000);
Vypis(a);
QuickSort(a, 1, N);
Vypis(a);
ReadLn;
end.Četnost písmen v textovém souboru
Program typu .TTP: jméno souboru dostane jako parametr, případně se na něj zeptá.
program Cetnost;
var
f: Text;
jmeno: String;
c: Char;
pocty: array['A'..'Z'] of LongInt;
celkem, nejvic: LongInt;
i, delka: Integer;
begin
if ParamCount > 0 then
jmeno := ParamStr(1)
else
begin
Write('Soubor: ');
ReadLn(jmeno);
end;
Assign(f, jmeno);
{$I-} Reset(f); {$I+}
if IOResult <> 0 then
begin
WriteLn('Nelze otevrit ', jmeno);
ReadLn;
Halt(1);
end;
for c := 'A' to 'Z' do pocty[c] := 0;
celkem := 0;
while not Eof(f) do
begin
Read(f, c);
c := UpCase(c);
if c in ['A'..'Z'] then
begin
Inc(pocty[c]);
Inc(celkem);
end;
end;
Close(f);
nejvic := 1;
for c := 'A' to 'Z' do
if pocty[c] > nejvic then nejvic := pocty[c];
for c := 'A' to 'Z' do
begin
Write(c, pocty[c]:7, ' ');
delka := Round(pocty[c] * 60 / nejvic); { sloupcovy graf }
for i := 1 to delka do Write('#');
WriteLn;
end;
WriteLn('Celkem pismen: ', celkem);
ReadLn;
end.Telefonní seznam v typovém souboru
Přidávání, výpis a vyhledávání záznamů s přímým přístupem.
program Telefon;
uses Crt;
const
Soubor = 'TELEFON.DAT';
type
TZaznam = record
Jmeno: String[30];
Telefon: String[16];
end;
var
f: file of TZaznam;
z: TZaznam;
volba: Char;
procedure Otevri;
begin
Assign(f, Soubor);
{$I-} Reset(f); {$I+}
if IOResult <> 0 then Rewrite(f); { soubor jeste neexistuje }
end;
procedure Pridej;
begin
Write('Jmeno: '); ReadLn(z.Jmeno);
Write('Telefon: '); ReadLn(z.Telefon);
Seek(f, FileSize(f)); { na konec }
Write(f, z);
end;
procedure Vypis;
var i: LongInt;
begin
Seek(f, 0);
i := 0;
while not Eof(f) do
begin
Read(f, z);
Inc(i);
WriteLn(i:3, ' ', z.Jmeno:30, ' ', z.Telefon);
end;
WriteLn('Zaznamu: ', FileSize(f));
end;
function Velka(s: String): String;
var i: Integer;
begin
for i := 1 to Length(s) do s[i] := UpCase(s[i]);
Velka := s;
end;
procedure Hledej;
var co: String;
nalezeno: Boolean;
begin
Write('Hledat (cast jmena): '); ReadLn(co);
co := Velka(co);
nalezeno := False;
Seek(f, 0);
while not Eof(f) do
begin
Read(f, z);
if Pos(co, Velka(z.Jmeno)) > 0 then
begin
WriteLn(z.Jmeno, ': ', z.Telefon);
nalezeno := True;
end;
end;
if not nalezeno then WriteLn('Nic nenalezeno.');
end;
begin
Otevri;
repeat
WriteLn;
WriteLn('P = pridat, V = vypis, H = hledat, K = konec');
volba := UpCase(ReadKey);
case volba of
'P': Pridej;
'V': Vypis;
'H': Hledej;
end;
until volba = 'K';
Close(f);
end.Přetečení Integer
Integer má jen 16 bitů. Výraz 300 * 300 se počítá v rozsahu Integer a přeteče dřív, než se uloží do proměnné LongInt. Aspoň jeden operand převeďte: LongInt(300) * 300. Při ladění pomáhá {$R+}.
Středník před else
if … then Prikaz; else … je syntaktická chyba, středník ukončí celý příkaz if. Naopak v case před else středník být smí.
Program po spuštění zmizí
Textové programy spouštěné z desktopu po skončení zavřou okno. Přidejte na konec ReadLn nebo čekání na klávesu přes ReadKey.
Diakritika
Znaková sada Atari ST neobsahuje česká písmena. Řetězce v programech pište bez háčků a čárek, jinak se zobrazí jiné znaky. Totéž platí pro soubory přenášené z PC: znaky nad kódem 127 se liší.
Zásobník a rekurze
Hluboká rekurze nebo velká lokální pole (např. array[1..10000] of Integer uvnitř procedury) mohou přeplnit zásobník. Velká data deklarujte globálně nebo alokujte na haldě přes New/GetMem.
Ukazatele po Dispose
Po Dispose(p) obsahuje p stále starou adresu. Pokud ho dál testujete, nastavte ho ručně na nil.
Typové soubory a String
Do záznamů ukládaných do souboru dávejte String[n] s rozumnou délkou, ne holý String. Každý záznam zabírá plnou deklarovanou velikost.
Přenos z Turbo Pascalu na PC
Unity Graph, Overlay a přímý přístup k portům, přerušením a segmentům (Mem, Port, Intr) jsou specifické pro PC. Grafiku na ST přepište do VDI, systémová volání do unitu Dos nebo příslušných TOS unitů ◆.