HighSpeed Pascal pro Atari ST

Příručka jazyka s referencí standardních rutin, unity Crt, Dos a GEM a s ukázkovými programy, které můžete rovnou zkopírovat do editoru.

Začít Reference
×

Úvod a prostředí

◇

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

AHOJ.PAS
program Ahoj;
begin
  WriteLn('Ahoj, Atari ST!');
  WriteLn('Stiskni Return...');
  ReadLn;
end.
×

Struktura programu

◇

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.

STRUKT.PAS
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.

×

Datové typy

◇
TypRozsah / popisVelikost
ShortInt−128 .. 1271 B
Byte0 .. 2551 B
Integer−32 768 .. 32 7672 B
Word0 .. 65 5352 B
LongInt−2 147 483 648 .. 2 147 483 6474 B
Realreálné číslo; přesnost a rozsah závisí na implementaci ◆dle verze
BooleanFalse, True1 B
Charjeden znak (kód 0..255)1 B
Stringřetězec do 255 znaků; String[n] do n znakůn + 1 B
Pointernetypový ukazatel; ^T typový4 B
Texttextový soubor—

Uživatelské typy

Deklarace typů
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í.

Typované konstanty
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.
×

Operátory

◇

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).

PrioritaOperátoryVýznam
1not @negace, adresa
2* / div mod and shl shrnásobení, reálné dělení, celočíselné dělení, zbytek, logický/bitový součin, posuny
3+ - or xorsčítání, odčítání, sjednocení řetězců, logický/bitový součet
4= <> < > <= >= inporovná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.

×

Řídicí struktury

◇
Větvení a cykly
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.

×

Procedury a funkce

◇

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.

PODPROG.PAS
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+} ◆.

×

Řetězce

◇

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.

RutinaPopisPříklad
Length(s)délka řetězceLength('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 0Pos('ST', 'Atari ST') = 7
Insert(sub, s, i)vloží sub do s na pozici iprocedura, mění s
Delete(s, i, n)smaže n znaků od pozice iprocedura, mění s
Concat(s1, s2, …)spojení řetězcůtotéž jako s1 + s2
Str(x:w:d, s)číslo na řetězec s formátemStr(3.14159:0:2, s) → '3.14'
Val(s, x, kod)řetězec na číslo; kod = 0 při úspěchu, jinak pozice chybyVal('123', n, k)
UpCase(c)velké písmeno (jen pro Char)UpCase('a') = 'A'
Chr(n), Ord(c)převod kód ↔ znakOrd('A') = 65
RETEZCE.PAS
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.
×

Soubory

◇

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).

TEXTSOUB.PAS
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.

KOPIE.PAS
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.
×

Ukazatele a dynamická paměť

◇

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.

SEZNAM.PAS
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.
×

Vlastní unity

◇

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.

MATIKA.PAS
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.
TESTMAT.PAS
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

◇

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 ◆.

RutinaPopis
ClrScrsmaže obrazovku a nastaví kurzor do levého horního rohu
ClrEolsmaže řádek od kurzoru do konce
GotoXY(x, y)přesune kurzor na sloupec x, řádek y
WhereX, WhereYaktuální pozice kurzoru
KeyPressedTrue, pokud čeká stisknutá klávesa (nečeká na ni)
ReadKeypř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
MENU.PAS
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

◇

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).

RutinaPopis
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.

VYPIS.PAS
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.
×

GEM: AES a VDI

◇

◆ 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íVrstvaPopis
appl_initAESpřihlášení aplikace, vrací ap_id (−1 = chyba)
appl_exitAESodhlášení před koncem programu
graf_handle(…)AEShandle fyzické stanice a rozměry systémového písma
graf_mouse(tvar, nil)AEStvar kurzoru myši (šipka, přesýpací hodiny, skrytí)
form_alert(def, text)AESalert box; vrací číslo stisknutého tlačítka
evnt_keybdAESčeká na stisk klávesy
v_opnvwk(in, h, out)VDIotevře virtuální pracovní stanici
v_clsvwk(h)VDIzavře ji
v_clrwk(h)VDIsmaže obrazovku
v_pline(h, n, pxy)VDIlomená čára přes n bodů
v_gtext(h, x, y, s)VDIgrafický text
v_circle(h, x, y, r)VDIvyplněný kruh
vsf_interior(h, styl)VDIstyl 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).

GEMDEMO.PRG ◆
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 kompilátoru

◇

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 ◆.

DirektivaVý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
Typické použití
{$R+,S+}            { pri ladeni }
program Ladeni;
{$I KONSTANTY.INC}  { sdilene deklarace }
begin
  { ... }
end.
×

Reference standardních rutin

◇

Rutiny z unitu System, který je dostupný vždy bez uvedení v uses.

Aritmetika

RutinaPopis
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
Pi3,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
Randomizeinicializace generátoru náhodných čísel
Odd(n)True pro liché číslo

Ordinální typy

RutinaPopis
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

RutinaPopis
New(p), Dispose(p)alokace a uvolnění typového ukazatele
GetMem(p, n), FreeMem(p, n)alokace a uvolnění n bajtů
MemAvail, MaxAvailvolná 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), @xadresa proměnné
ParamCount, ParamStr(i)parametry příkazové řádky (programy .TTP)
Exit, Halt(kod)konec podprogramu, konec programu

Vstup a výstup

RutinaPopis
Write, WriteLnvýstup; formát x:šířka a u reálných x:šířka:desetiny
Read, ReadLnvstup z klávesnice nebo souboru
Assign(f, jmeno)spojí proměnnou souboru se jménem
Reset, Rewrite, Appendotevř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, BlockWriteblokové čtení a zápis netypových souborů
Erase(f), Rename(f, nove)smazání a přejmenování (soubor nesmí být otevřený)
IOResultkód poslední V/V chyby při {$I-}
MkDir, RmDir, ChDir, GetDirpráce s adresáři
×

Ukázkové programy

◇

Eratosthenovo síto

Prvočísla do 10 000 pomocí pole logických hodnot.

SITO.PAS
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

RAZENI.PAS
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á.

CETNOST.PAS
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.

TELEFON.PAS
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.
×

Tipy a časté chyby

◇

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ů ◆.