Chip 2001 July/Chip_2001-07_cd1.bin/ctenari/Cerny/INSTALLF.EXE/rar/FREETFB/DOC/PRIKAZY.DOC

Text File | 2001-05-14 | 54KB | 1,194 lines

~16|0|05 Klíƒová slova, p²íkazy a operátory
~16|0|05         v Turbo Fast Building PRO256

 |1|05 1.1  ü //NAZEV//        |0|12(dv╪ pravá lomítka)
    Uvádí se na zaƒátku kaºdého zdrojového textu a oznaƒuje název
 programu. Název programu nemusí b∞t shodn∞ s názvem diskového souboru ve
 ve kterém je program uloºen.
 P²íklad:
          |1|09//|1|12MujProgram|1|09//  |0|12(dv╪ pravá lomítka)
 Soubor màºeme uloºit t²eba pod názvem "main.fbs" (po kompilaci MAIN.EXE)

 |1|05 1.2  ü \\NAZEV\\        |0|12(dv╪ levá lomítka)
    Uvádí se na zaƒátku kaºdého zdrojového textu a oznaƒuje název
 jednotky .FBL. Název jednotky za tímto klíƒov∞m slovem musí b∞t shodn∞
 s názvem diskového souboru, ve kterém je jednotka uloºena.
 P²íklad:
          |1|09\\|1|12Adresy|1|09\\
 Soubor musí mít stejné jméno "ADRESY.FBS" (po kompilaci ADRESY.FBL)

 |1|05 1.3  ü ==
    Symbol pro logické p²i²azení obsahu prom╪nn∞ch.
 P²íklad:
          |1|12A |1|09== |1|12b;
          |1|12Ret |1|09== |1|12'Karel';
          a pod.
 Pamatujte, ºe dvojité rovnítko == p²i²azuje hodnotu prom╪nn∞ch, kdeºto
 jednoduché rovnítko = potvrzuje, skuteƒnou hodnotu v prom╪nné. Nesmí proto
 dojít k zám╪n╪. Pi²azování hodnot prom╪nn∞m lze vτak provést p²ehledn╪ji
 jeτt╪ dalτím klíƒov∞m slovem let, dále v sekveci :let> nebo pomocí slova
 if V∞raz let .....;
 - viz kap.L. odst.1,2 a 3.

 |1|05 1.4  ü :>  |0|12(dvouteƒka s pravou lomenou závorkou)
    Tento symbol oznaƒuje zaƒátek procedury nebo funkce. Za symbol je
 moºné vloºit struƒnou poznámku, která nesmí obsahovat mezery a musí b∞t
 ukonƒena znakem > za kter∞ se jiº neuvádí st²edník.
 P²íklad:
       |0|09Main Secti(x,y:integer);
       |1|09:>|0|09proc>
       |0|09  if x < 10 part
       |0|09    let x : 10;
       |0|09  :if<x<
       |0|09:<proc<

 |1|05 1.5  ü :<  |0|12(dvouteƒka s levou lomenou závorkou)
    Tento symbol oznaƒuje konec procedury nebo funkce. Za symbol je
 moºné vloºit struƒnou poznámku, která nesmí obsahovat mezery a musí b∞t
 ukonƒena znakem < za kter∞ se jiº neuvádí st²edník.

 P²íklad:
       |0|09Main Secti(x,y:integer);
       |0|09:>proc>
       |0|09  if x < 10 part
       |0|09    let x : 10;
       |0|09  :if<x<
       |1|09:<|0|09proc<

 |1|05 1.6  ü @náv╪τtí<   |0|12(@ zavináƒ)
    Znak "zavináƒ" slouºí pro oznaƒení definovaného náv╪τtí. Uvádí se
 p²ed jménem náv╪τtí, za které se uvede levá lomená závorka.

 |1|05 1.7  ü &   |0|09(& znak pro AND)
    Operátor se pouºívá p²edevτím u klíƒového slova |1|12if|0|12, kde je t²eba
 urƒit více podmínek, které platí souƒasn╪.
 P²íklad:
   |0|09if (a<b) |1|09& |0|09(d>e) next
   nebo |0|09if (a<b) |1|09& |0|09(d>e) part
      v tomto p²ípad╪ je podmínkou, ºe -a- je menτí neº -b- a souƒasn╪
      -d- je vetτí neº -e-.

 |1|05 1.8  ü ÷   |0|12(÷ znak pro OR)
    Operátor se pouºívá p²edevτím u klíƒového slova |1|12if|0|12, kde je t²eba
 urƒit více podmínek, u kter∞ch je povoleno více moºností souƒasn╪.
 P²íklad:
   |0|09if (a<b) |1|09÷ |0|09(d>e) next
   nebo |0|09if (a<b) |1|09÷ |0|09(d>e) part
      v tomto p²ípad╪ je podmínkou, ºe -a- je menτí neº -b- a nebo
      -d- je v╪tτí neº -e-.

 |1|05 1.9  ü !!   |0|12(!! znaky pro NOT)
    Operátor se pouºívá p²edevτím u klíƒového slova |1|12if|0|12, kde se zjiτ£uje
 hodnota typu boolean (pravda=True a nepravda = False).
 V tomto p²ípad╪ se zjiτ£uje, zda hodnota typu boolean je False, nebo
 jinak NOT.
 P²íklad:
      |0|09if |1|09!!|0|09Maska next ...   |0|12je-li Maska = False
      |0|09if |1|09!!|0|09Maska part
      v tomto p²ípad╪ je zjiτ£uje, zda hodnota booleanovské prom╪nné
      Maska je záporná (NOT), tedy False;
      Pro zjiτt╪ní, zda je True se !! neuvedou.

 |1|05 1.11  ü |0|05~  |0|12(znak pro rozvinou variaci)
    Pouºívá se za p²eddefinovan∞m ordinálním, logick∞m nebo vlastním
 typem po klíƒovém slovu variable.

 |1|05 1.12  ü <>, >, <
    Lomené závorky uzavírají instrukce u p²íkazà #include a #call.
    |0|09#include |1|09<|0|09soubor|1|09>
    |0|09#call |1|09<|0|09soubor.obj|1|09>
 Lomená závorka vpravo se vyskytuje u skevenƒních slov, která oznaƒují
 zaƒátek sekvence. Uvád╪jí se v kombinaci se znakem dvouteƒky :
   |0|09:let>      |0|12zaƒátek sekvence p²i²azování hodnot prom╪nn∞m
   |0|09:loop>     |0|12zaƒátek podmín╪né sekvence
   |0|09:otherdo>  |0|12zaƒátek pokraƒující sekvence s dalτím moºn∞m ²eτením

 Lomená závorka vlevo se vyskytuje u skevenƒních slov, která oznaƒují
 konec sekvence. Uvád╪jí se v kombinaci se znakem dvouteƒky :
   |0|09:let<      |0|12konec sekvence p²i²azování hodnot prom╪nn∞m
   |0|09:loop< ... |0|12konec podmín╪né sekvence
   |0|09:otheron<  |0|12konec sekvence s následn∞m moºn∞m ²eτením
   |0|09:other<    |0|12konec následné sekvence
   |0|09:case<     |0|12konec cyklu CASE zahájeného slovem part
   |0|09:for<      |0|12konec urƒené sekvence FOR zahájené slovem part
   |0|09:if<       |0|12konec sekvence po IF zahájené slovem part
   |0|09:with<     |0|12konec cyklu WITH zahájeného slovem part
   |0|09:while<    |0|12konec cyklu WHILE zahájeného slovem part

 |1|05 1.13  ü |0|05#
    Identifikátor se uvádí p²ed p²íkazem #include a #unit.

 |1|05 1.14  ü []
    Hranaté závorky uzavírají popis deklarovaného pole nebo popisku pole.

 |1|05 1.15  ü / a \
    Pravé lomítko se pouºívá u klíƒového slova FOR pro oznaƒení sm╪ru
 stoupání cyklu od menτí hodnoty k vyττí:
    |0|09for n,1|1|09/|1|0910  |0|12cyklus stoupá od 1 do 10
    Dále se pravé lomítko pouºívá u slov pro práci se soubory, pokud
 jsou neurƒeného typu:
    |0|09OpenF(f|1|09/|0|091,SOUBOR);
    |0|09CreateF(f|1|09/|0|091,SOUBOR);
    |0|09OpenF(f|1|09/|0|091,SOUBOR);
    Pouºívá se rovn╪º u slov DefVal a Declare pro urƒení typu:
    |0|09DefVal Jmeno:N|1|09/|0|09typ) .....
    |0|09Declare : Pole[h1-h2|1|09/|0|09typ .....

    Levé lomítko se pouºívá u klíƒového slova FOR pro oznaƒení sm╪ru
 stoupání cyklu od vyττí hodnoty k niºτí:
    |0|09for n,10|1|09\|0|091  |0|12cyklus klesá od 10 do 1


~16|1|05  A

 |1|05 A.1  ü AppendF@errlab(f,'text.txt');
 |1|05        AppendF(f,'text.txt');
    P²i²adí jméno externího textového jiº existujícího souboru na disku
 a otevírá ho pro p²idání dat na jeho konec. Podmínkou je, aby diskov∞
 soubor skuteƒn╪ existoval. Pokud tomu tak není, operace nebude provedena,
 V p²ípad╪, ºe za slovo AppendF@ uvedete jméno náv╪τtí, od kterého má
 program pokraƒovat v p²ípad╪ chyby, vypíτe se informaƒní okno s popisem
 a ƒíslem chyby, a program bude pokraƒovat od definovaného náv╪τtí.
 Pokud je soubor jiº otev²en∞, nejprve se uzav²e a poté se op╪t otev²e.
 |1|05P²íkaz Assign se v tomto p²ípad╪ p²ed AppendF  n e u v á d í !
 |1|05Neuvádí se ani p²epínaƒ {$I-} a {$I+}, nebo ResOff a ResOn,
 |1|05které jsou jiº souƒástí tohoto p²íkazu. Pokud je za znakem @
 |1|05uvedeno náv╪τtí, bude program pokraƒovat v p²ípad╪ chyby od toho
 |1|05náv╪τtí. Podmínkou vτak je, ºe náv╪τtí je definováno klíƒov∞m
 |1|05slovem DefFrom, a ºe toto náv╪τtí skuteƒn╪ existuje!
 |1|05Musí b∞t za slovem #unit uvedena jednotka IOErrFB.

~16|1|05  B

 |1|05 B.1  ü BlockRead@(f, pole, velikost, N);
 |1|05 B.2  ü BlockWrite@(f, pole, velikost, N);
   U souborà bez udaného typu màºeme pouºít místo Read a Write ke
 ƒtení a zápisu dat dv╪ speciální procedury BlockRead a BlockWrite.
 Uvedené procedury pracují s definovan∞m záznamem, jehoº velikost
 byla urƒena p²i otev²ení souboru. Procedura BlockRead naƒítá tedy
 data jako blok urƒené velikosti. Màºe se stát, ºe b╪hem naƒítání
 bloku dojde k neoƒekávané chyb╪, která pak konƒí DOSovsk∞m hláτením
 Error 100 (nebo jiné). Proto TFBPRO nabízí programátorovi klíƒové
 slovo BlockRead@ a BlockWrite@, které zachytí p²ípadnou chybu
 p²i zápisu nebo ƒtení bloku. Pokud je za slovem znak @ a je uvedeno
 jméno náv╪τtí, bude program v p²ípad╪ chyby pokraƒovat od tohoto náv╪τtí.
 |1|05Podmínkou vτak je, ºe za slovem #unit je uvedena jednotka IOErrFB !
 P²íklad pouºití:
 |0|09#unit GraphFB, ....., |1|09IOErrFB;
 |0|09Main CopyFile(FileTo,CopyTo:string);
 |0|09variable
 |0|09   file~FromF,ToF;
 |0|09   word~NunRead,NumWriten;
 |0|09   Declare : Buf[1..2048/of char];
 |1|09DefFrom ErrCopy,EndCopy;
 |0|09:>proc>
 |0|09  OpenF@ErrCopy(FromF/1,FileTo);
 |0|12  pokud doτlo k chyb╪ p²i otev²ení souboru jdi na ErrCopy
 |0|09  CreateF@ErrCopy(ToF/1,CopyTo);
 |0|12  pokud doτlo k chyb╪ p²i vytvo²ení souboru jdi na ErrCopy
 |0|09  :loop>
 |1|09     BlockRead@EndCopy(FromF, Buf, SizeOf(Buf), NumRead);
 |0|12     pokud doτlo k chyb╪ p²i ƒtení ze souboru jdi na EndCopy
 |1|09     BlockWrite@EndCopy(ToF, Buf, NumRead, NumWriten);
 |0|12     pokud doτlo k chyb╪ p²i zápisu do souboru jdi na EndCopy
 |0|09  :loop< (NumRead=0) ÷ (NumWriten <> NumRead);
 |1|09  @EndCopy<
 |0|09  Close(FromF);
 |0|09  Close(ToF);
 |1|09  @ErrCopy<
 |0|09:<proc<


~16|1|05  C

 |1|05 C.1  ü Call <soubor>
    Slouºí pro p²ipojení binárního souboru, kter∞ je v∞stupem p²ekladu
 z asembleru, Turbo C++ a jin∞ch p²ekladaƒà. Direktiva tedy dovoluje
 p²ipojení modulà p²eloºen∞ch z jin∞ch jazykà. Implicitní rozτí²ení je
 .OBJ. Soubor se hledá v aktivním adresá²i a pak v adresá²ích, které
 jsou zadány v konfiguraƒním souboru p²ekladaƒe.
 P²íklad :
          |0|09Main GP_BOX(X1,Y1,X2,Y2:integer); external;
          |1|09Call <GP_BOX.OBJ>

 |1|05 C.2 ü Case vyraz part
 |1|05     ü case> ....
 |1|05     ü :case<
    P²íkaz ²eτí v∞b╪r práv╪ jedné z moºností. Skládá se z v∞razu
 (tzv. selektor) a seznamu p²íkazà. Selektor musí b∞t ordinálního
 typu. Typ ²et╪zec a longint jsou nep²ípustné typy selektoru.
 P²íklad:  |1|09Case |1|09Vyraz part
           |1|09  case>|1|091 :>
           |0|09           p²íkaz1;
           |0|09           p²íkaz2;
           |0|09         :<
           |1|09  case>|1|092 p²íkaz
           |0|09          else
           |0|09         p²íkaz;
           |1|09:case<
 Konec této sekvence ukonƒíme klíƒov∞m slovem :case< do kterého màºeme
 vloºit p²ípadnou poznámku, kterou ukonƒíme dalτím znakem < a jiº
 neuvádíme znak st²edníku.

 |1|05 C.3  ü CreateF@errlab(f,'soubor.xxx');
 |1|05      ü CreateF@errlab(f/v,'soubor.xxx');
 |1|05      ü CreateF(f,'soubor.xxx');
 |1|05      ü CreateF(f/v,'soubor.xxx');
    P²i²adí jméno nového externího souboru, kter∞ vzáp╪tí vytvo²í a otev²e.
 Pokud soubor tohoto jména a typu jiº existuje, jeho obsah vymaºe. Pokud
 byl soubor jiº otev²en, nejprve se uzav²e, poté se znovu vytvo²í a otev²e.
 Pokud se otev²e textov∞ soubor, je otev²en∞ pouze pro zápis.
    Parametr -v- (velikost) je voliteln∞ a jedná se o v∞raz typu word.
 Definuje velikost bloku u souborà bez udaného typu, u typov∞ch nebo
 textov∞ch souborà se parametr velikost  n e u v á d í .
 V p²ípad╪ znaku @ za slovem, je uvedeno jméno náv╪τtí, od kterého má
 program pokraƒovat v p²ípad╪ chyby, vypíτe se informaƒní okno s popisem
 a ƒíslem chyby, a program bude pokraƒovat od definovaného náv╪τtí.
 |1|09P²íkaz Assign se v tomto p²ípad╪ p²ed CreateF  n e u v á d í !
 |1|09Neuvádí se ani p²epínaƒ {$I-} a {$I+}, nebo ResOff a ResOn,
 |1|09které jsou jiº souƒástí tohoto p²íkazu. Pokud je za slovem znak @
 |1|09a je uvedeno náv╪τtí, bude program pokraƒovat v p²ípad╪ chyby
 |1|09od tohoto náv╪τtí. Podmínkou vτak je, ºe náv╪τtí je definováno
 |1|09klíƒov∞m slovem DefFrom, a ºe toto náv╪τtí skuteƒn╪ existuje!
 |1|09Musí b∞t za slovem #unit uvedena jednotka IOErrFB.

~16|1|05  D

 |1|05 D.1 ü Declare : Pole[r1-r2/typ];
 |1|05 D.1 ü Declare : Pole[r1-r2/typ
 |1|05                = (..........)];
    Definuje datové pole uvedeného typu. Urƒuje se rozm╪r pole a typ
 sloºek. Rozm╪r pole (r1 aº r2) urƒuje, kolik prvkà se màºe do pole
 vloºit. Typ sloºky (typ) pole se urƒuje idetifikátorem za lomítko.
 Celá definice musí b∞t uzav²ena do hranat∞ch závorek a ukonƒena
 st²edníkem. Funkci musí p²edcházet ²íkaz variable, var nebo type.
 P²íklad 1: |1|09variable
            |1|09  Declare : Pole[1-50/integer];
            |1|09  Declare : Pole[0-255,0-16/byte];
            |1|09  Declare : Radek[1-20/string[15]];

 P²íklad 2: |1|09type
            |1|09  Declare = SPole[1-4096/char];
            |1|09  Declare = ObrType[1-200/^SPole];
    Pokud je deklarace delτí a nebo za urƒen∞m typem pokraƒuje definice
 hodnot v uzav²en∞ch závorkách, je nutné pokraƒovat na dalτím ²ádku nebo
 ²ádcích, je nutné dodrºet deklaraci na prvním rádku základních parametrà
 a na dalτím ²ádku pokraƒovat, p²itom identifikátor = , kter∞m parametry
 pokraƒují smí b∞t aº na tomto dalτím ²ádku.
 P²íklad : |0|09 const
           |0|09    Declare : Dny[1-7/string[7]
                   |1|09= |0|09('Pond╪lí','Θter∞','St²eda',+
           |0|09        '¼tvrtek','Pátek','Sobota','Ned╪le')];
 nebo
           |0|09 const
           |0|09    Declare : Page[1-25,1-80/record
           |0|09         ch, atr : char
           |0|09         end absolute $B800:$0000];
 teprve na ²ádku s posledním parametrem se uvede ]; hranatá závorka se
 st²edníkem.

 |1|05 D.2 ü DefFrom .....;
   Definici náv╪τtí uvádí klíƒové slovo DefFrom. Náv╪τtí je posloupnost
 ƒíslic v rozsahu 0 aº 9999. Náv╪τtí definuje místo, na které se provádí
 skok p²íkazem From. Proti standartnímu Pascalu p²ipouτtí TFBP pouºívání
 identifikátorà ve funkci náv╪τtí.
 P²íklad:
 |1|09DefForm |1|091, 2, Ven, 3;
 |0|09:>proc>
 |0|09  ....
 |1|09  From 1;
 |0|09  ....
 |1|09  From Ven;
 |0|09  ....
 |1|09  @Ven<
 |0|09  ....
 |1|09  @1<
 |0|09:<proc<

 |1|05 D.3 ü DefVal Name:N/typ = (....);
    Klíƒové slovo DefVal uvádí deklaraci konstant v programu. Konstanty
 jsou prvky programu, které v pràb╪hu provád╪ní programu nem╪ní svou
 hodnotu. Za klíƒové slovo DefVal se uvede jméno definované konstanty.
 Na toto jméno se bude odvolávat klíƒové slovo Def(Name,N). Za dvouteƒku
 uvedeme nejprve parametr N, kter∞ urƒuje poƒet deklarovan∞ch hodnot.
 Jako dalτí parametr uveden∞ za lomítko se musí uvést typ konstanty,
 kter∞ màºe b∞t typu integer, word, longint, real, char nebo boolean.
 Hodnoty uvedeného typu uvedeme za rovnítko do závorky a odd╪lujeme je
 ćrkou.
 Jejich poƒet musí odpovídat uvedenému parametru N. Celou definici
 ukonƒíme op╪t závorkou a st²edníkem. Toto klíƒové slovo màºe b∞t uvedeno
 v deklaraƒní ƒásti programu, procedury nebo funkce. Nikdy vτak nesmí b∞t
 uvedeno uvnit² sekvence!
 P²íklad zadání:
 |1|09DefVal TG:4/integer = (10,80,100,630);
     nebo
 |1|09DefVal OP:15/byte =
 |1|09   (175,212,89,45,247,118,79,25,220,67,156,34,148,198,200);

 |1|05 D.4 ü Def(Name,N)
    Toto klíƒové slovo pouºijeme pro vyzvednutí hodnot v definované
 deklaraci konstant. Do závorek uvedeme jméno existující definice a
 poƒet hodnot, které z této definice chceme pouºít. Parametr N vτak
 nesmí b∞t v╪tτí neº skuteƒn∞ poƒet hodnot ani se nesmí rovnat nule.
 Pokud parametr N udává menτí hodnotu, neº je maximální poƒet hodnot
 v definici uvedeného jména, budou vyzvednuty hodnoty od 1 do N.
 Jako p²íklad si uvedeme p²i²azení hodnot pro proceduru OptionalArea,
 u které je nutno uvést: stav,X1,Y1,X2,Y2, sv.stín,tm.stín a barvu
 plochy. Hodnoty deklarujeme jako konstanty do definice oznaƒené
 jménem Area.
 |1|09  DefVal Area:8/integer = (Active,10,80,100,630,7,8,6);
 proceduru OptionalArea pak màºeme volat takto:
 |1|09  OptionalArea(|1|09Def(Area,8)|1|09);
 místo
 |1|09  OptionalArea(Active,10,80,100,630,7,8,6);
 Pokud si mimo to jeτt╪ definujeme i poslední t²i hodnoty, které se
 b╪hem programu mohou u stejného p²íkazu m╪nit, màºeme uvést kombinaci
 více klíƒov∞ch slov Def(Name,N).
 P²íklad:
 |1|09DefVal Color:3/byte = (11,1,4); |0|12hodnoty pro barvy
 |1|09OptionalArea(|1|09Def(Area,5),Def(Color,3)|1|09);
 Z první definice budou vyzvednuty hodnoty od 1 do 5 a z druhé definice
 od 1 do 3.

~16|1|05  E

 |1|05 E.1  ü EndFo
     Oznaƒuje konec hlavní / ²ídící ƒásti programu a souƒasn╪ oznaƒuje
 konec celého programu. Toto klíƒové slovo smí b∞t pouºito pouze jednou
 v celém zdrojovém textu programu.
 P²íklad: |0|09  ......
          |0|09  DisposeFB;
          |1|09EndFo

~16|1|05  F

 |1|05 F.A ü FarOn;
 |1|05     ü FarOff;
     Na poćtku -
  Lokální p²epínaƒ, kter∞ ²ídí model volání podprogramà. Pouºívají se
  dva modely, dalek∞ (FAR = FarOn;) a blízk∞ (NEAR, FarOff;). Procedury
  a funkce p²eloºené s p²epínaƒem FarOn pouºívají dalek∞ model, tj. volají
  se instrukcí CALL FAR.
     Pro blízk∞ model volání se pouºívá pouze adresa ofsetu v daném
  segmentu, pro dalek∞ model volání se ukládá vºdy adresa segmentu
  i ofsetu.

 |1|05 F.1 ü For n,ph/kh part
 |1|05     ü For n,kh\ph part
 |1|05     ü :for<
 |1|05     ü For n,ph/kh next ....;
 |1|05     ü For n,kh\ph next ....;
 |1|05     ü For n,kh/ph let ....;
 |1|05     ü For n,kh/ph if ... next ...;
    P²íkaz zajistí p²edem urƒen∞ poƒet opakování jednoduchého nebo
 sloºeného p²íkazu. ⁿídící prom╪nná musí b∞t ordinálního typu a uvádí
 se p²ed ƒárkou, za kterou se uvede poƒáteƒní (ph) a koneƒná hodnota (kh),
 ty musí b∞t kompatibilní pro p²i²azení s ordinálním typem a musí b∞t
 ukonƒeny slovem part (v p²ípad╪ rozvinutí sekvence), next (pro jedno-
 rázové ²eτení) nebo let (pro p²i²azení hodnot).
 Operand / (pravé lomítko) urƒuje zvyτování cyklu od poƒáteƒní hodnoty
 ke koncové a operand \ (levé lomítko) od koncové k poƒáteƒní hodnot╪.
 Bude-li ph 1 a kh 20, pak bude uvedeno 1 / 20 a cyklus bude probíhat od
 1 do 20 (vzestupn╪). Bude-li ph 20 a kh 1, pak bude operand uveden
 20 \ 1 a cyklus bude probíhat od 20ti do 1 (tedy sestupn╪).
 Pokud bylo za urƒením opakování uvedeno slovo part, musí b∞t konec
 sekvence oznaƒena slovem :for< do kterého màºeme vloºit p²ípadnou poznámku,
 kterou ukonƒíme dalτím znakem < a jiº neuvádíme znak st²edníku.

 P²íklad sekvenƒního pouºití:
          |1|09for |0|09a,1/10 |1|09part
          |0|09  .....
          |0|09  .....
          |1|09:for<a<
 nebo jednorázového pouºití:
          |1|09for |0|09a,1/10 |1|09next |0|09Writeln('.....');
          |1|09for |0|09a,1/10 |1|09if |0|09Vyraz |1|09next ....;
          atd.
 nebo
         |1|09for |0|09a,1/10 |1|09let |0|09Prom[a] : a;
 u spojení se slovem let màºe b∞t také uvedeno slovo else:
         |1|09for |0|09a,1/10 |1|09let |0|09Prom[a] : a |1|09else |0|09Prom[a] : 0;


 |1|05 F.2  ü From ....;
    P²íkaz p²edá ²ízení p²i provád╪ní programu na náv╪τtí definované
 v argumentu p²íkazu. Náv╪τtí se musí deklarovat ve stejném bloku programu,
 ve kterém je From pouºit. Pokud se náv╪τtí deklaruje uvnit² procedury
 nebo funkce, není povolen skok mimo t╪lo procedury nebo funkce.
 P²íklad: |0|09Main Jmeno;
          |0|09DefFrom |1|09Start;
          |0|09:>proc>
          |1|09  @Start<
          |0|09  ......
          |0|09  If a = b |1|09From |0|09Start;
          |0|09:<proc<

 |1|05 F.3  ü Func .....;
    Oznaƒuje název vlastní funkce. Za názvem funkce musí b∞t st²edník.
 Zaćtek funkce oznaĒme symbolem :> pro zaćtek a symbolem :< konce.
 P²íklad: |1|09Func |0|09Secti(h1,h2 : word) : word;
          |0|09:>func>
          |0|09    t╪lo funkce
          |0|09:<func<

 |1|05 F.4  ü FuncInside .....;
  Oznaƒuje název vloºené funkce v Main nebo Func. Za názvem funkce musí
 b∞t st²edník. Vloºená funkce FuncInside màºe b∞t volána pouze v rámci
 procedury Main/Func. Zaćtek funkce oznaĒme symbolem pro zaćtek :>
 a konec symbolem pro konec :<
 P²íklad: |0|09Main Pocitani(Hod : integer); |0|12hlavní procedura
          |0|09variable
          |0|09  integer~ X;

          |1|09  FuncInside |0|09Secti : integer      |0|12vloºená funkce
          |1|09  :>fins>                  |0|12zaƒátek vloºené funkce
          |1|09    obsah vloºené funkce
          |1|09  :<fins<                  |0|12konec vloºené funkce

          |0|09:>proc>                    |0|12zaƒátek hlavní procedury
          |0|09    t╪lo procedury
          |0|09:<proc<                    |0|12konec hlavní procedury

 |1|05 F.5  ü Follow
     Oznaƒuje zaƒátek hlavního t╪la programu (jeho ²ídící ƒást). Na rozdíl
 od b╪ºné procedury tato ƒást nezaƒíná symbolem :> pro zaƒátek ani klíƒov∞m
 slovem begin, které se ve TFB tém╪² nepouºívá. Klíƒové slovo Follow smí
 b∞t pouºito pouze jednou v celém zdrojovém textu programu.
 P²íklad: |1|09Follow
          |0|09  InitFB;
                  atd.

~16|1|05  H

 |1|05 H.1  ü Heap <sss,min,max>
    Globální direktiva, která nastavuje velikost zásobníku
 (sss,od 1024 do 65520 byte), minimální velikost volné pam╪ti
 (min, od 0 do 655360 byte) a velikost pam╪ti pro haldu (max,
 od 0 do 655360 byte). Minimální velikost volné pam╪ti se
 kontroluje p²ed spuτt╪ním programu. Není-li pam╪£ k dispozici,
 program se ukonƒí s hláτením chyby. Velikost pam╪ti, která se
 p²id╪lí pro haldu, urƒuje maximální poºadavky na pam╪£. Není-li
 k dispozici tolik pam╪ti, p²id╪lí se vτechna zb∞vající. Pouºije-li
 se tato direktiva v jednotce, ignoruje se.
    V chrán╪ném reºimu se màºe pouze definovat velikost segmentu,
 nelze definovat velikost haldy.
 P²íklad : |0|09//Jmeno//
           |1|09Heap <4000,0,0>

~16|1|05  I

 |1|05 I.1  ü If Vyraz part
 |1|05      ü :if<
 |1|05      ü If Vyraz next ....;
 |1|05      ü If Vyraz let ....;
 |1|05      ü If Vyraz from ....;
    P²íkaz zjiτ£uje stav prom╪nné typu Boolen, je-li TRUE nebo FALSE (!!),
 a dalτí hodnoty uveden∞ch prom╪nn∞ch. Za p²íkazem následuje dalτí ²eτení
 v následující sekvenci, kterou oznaƒuje slovo part. Sekvence se ukonƒí
 klíƒov∞m slovem :if< do kterého màºeme vloºit p²ípadnou poznámku, kterou
 ukonƒíme dalτím znakem < a jiº neuvádíme znak st²edníku.

 P²íklad sekvenƒního pouºití:
          |1|09if |0|09v∞raz |1|09part
          |0|09  ...
          |1|09:if<
 pro jednorázové pouºití slouºí slova next, let a from. Klíƒové slovo if
 nesmí b∞t pouºito na jednom ²ádku vícekrát, ale pouze jednou.
 P²íklad:
         |1|09if |0|09vyraz |1|09let |0|09promenna : hodnota;
 nebo    |1|09if |0|09vyraz |1|09let |0|09promenna : hod1 else promenna : hod2;
 nebo    |1|09if |0|09vyraz |1|09next |0|09Procedura;
 nebo    |1|09if |0|09vyraz |1|09from |0|09Skok;

 |1|05 I.2  ü #include <soubor>
    V souboru se p²edpokládá zdrojov∞ text programu, jehoº obsah
 se vloºí na místo této direktivy. Soubor se hledá v podadresá²i
 ADD\ aktivního adresá²e, jehoº rozliτovací p²ípona je .ADD. Neuvádí
 se proto ani cesta k souboru ani jeho rozliτovací p²ípona.
 Blíºe v popisu souborà typu .ADD.
 P²íklad : |1|12#include <SwapWord>
 |1|05Pokud jsou ve zdrojovém textu souboru .ADD pouºita klíƒová slova
 |1|05a p²íkazy jazyka TFB nesmí b∞t pro jejich vloºení do zdrojového
 |1|05textu programu pouºita direktiva Pascalu {$I soubor.add} ! ! !

 |1|05 I.3  ü #include "cesta\soubor.typ"
    V souboru se p²edpokládá zdrojov∞ text programu, jehoº obsah
 se vloºí na místo této directivy. Soubor s uvedenou rozliτovací
 p²íponou se hledá v adresá²i uvedeného parametrem cesta.
 P²íklad : |1|12#include "c:\tp\inc\hexto.pas"
 |1|05Pokud jsou ve zdrojovém textu souboru .ADD pouºita klíƒová slova
 |1|05a p²íkazy jazyka TFB nesmí b∞t pro jejich vloºení do zdrojového
 |1|05textu programu pouºita direktiva Pascalu {$I soubor.add} ! ! !

~16|1|05  L

  |1|05 L.1  ü :let>
  |1|05      ü :let<
    Slovo :let> oznaƒuje zaƒátek sekvence, ve které se budou p²i²azovat
 hodnoty do v╪tτího mnoºství prom╪nn∞ch. Celá sekvence pak musí b∞t
 ukonƒena klíƒov∞m slovem :let< do kterého màºeme (stejn╪ jako u :let>)
 vloºit p²ípadnou poznámku, kterou ukonƒíme dalτím znakem < a jiº
 neuvádíme znak st²edníku (u :let<poznamka<) nebo > (u :let>poznamka>).
 |1|05P²i²azování hodnot musí pokraƒovat aº na následujícím ²ádku a nesm╪jí
 |1|05b∞t uvedena za slovem :let>. Je rovn╪º nep²ípustné uvedení obou slov
 |1|05na jednom spoleƒném ²ádku!

 P²íklad:
 |1|09:let>|0|09lret|1|09>
 |0|09  DelRet : length(PuvZn);
 |0|09 LfRet : Copy(LRet,1,Pos(PuvZn,LRet)-1);
 |0|09  RgRet : Copy(LRet,Pos(PuvZn,LRet)+DelRet,length(LRet));
 |1|09:let<|0|09lret|1|09<
    Tato slova lze velmi dob²e vyuºít ve funkcích nebo procedurách, které
 obsahují pouze p²id╪lování hodnot do prom╪nn∞ch a není proto nutné uvád╪t
 jiº oznaƒení zaƒátku a konce procedury nebo funkce. V takto oznaƒeném
 cyklu se vτak nesmí vyskytovat ºádná jiná klíƒová slova nebo p²íkazy.
 P²íklad:
 |0|09Main SwapWord(var VRet:string; PRet,NRet:string);
 |0|09variable
 |0|09  integer~DelRet;
 |0|09  string~LfRet,RgRet;
 |1|09:let>vret>
 |0|09  DelRet : length(PRet);
 |0|09  LfRet : Copy(VRet,1,Pos(PRet,VRet)-1);
 |0|09  RgRet : Copy(VRet,Pos(PRet,VRet)+DelRet,length(VRet));
 |0|09  VRet : LfRet+NRet+RgRet;
 |1|09:let<vret<

  |1|05 L.2  ü Let .... ;
    Toto klíƒové slovo oznaƒuje p²i²azení hodnoty nebo hodnot do uvedené
 prom╪nné za tímto slovem. Mezi prom╪nnou a hodnotou se uvádí jako
 rozliτovací znak dvouteƒka.
 Za slovem Let màºe b∞t uvedeno v jednom ²ádku i více hodnot.
 P²íklad:
 |1|09let |0|09A : B; Ret : '²et╪zec'; C : (d div 8);
    Pokud je p²i²azovaná hodnota ²et╪zcového typu a je delτí neº jeden
 ²ádek, ukonƒí se uvozovkou a znaménkem + a pokraƒuje se na dalτím ²ádku.
 P²íklad:
 |1|09let |0|09Ret : 'Funkce PosDigit hledá v ²et╪zci znaky z mnoºiny '|1|09+
 |0|09          '0 aº 9 a pokud takové v ²et╪zci nalezne, vrátí '|1|09+
 |0|09          'hodnotu pozice.'|1|09;
    Cel∞ tento ²ádek pak musí b∞t ukonƒen znakem st²edník ;

  |1|05 L.2b ü let(..,..,..,..) : Hodnota;
    Toto klíƒové slovo oznaƒuje |1|09hromadné |0|12p²i²azení hodnot do uveden∞ch
 prom╪nn∞ch. Prom╪nné musí b∞t |1|09stejného typu |0|12a p²i²azovaná hodnota musí
 b∞t pro vτechny spoleƒná a stejného typu jako prom╪nné. Pokud tedy
 pot²ebujeme p²i²adit stejnou hodnotu více prom╪nn∞m, màºeme toto slovo
 pouºít místo sekvenƒního |1|12:let>. |0|12P²edpokladem správnosti provedení je
 umíst╪ní názvà prom╪nn∞ch |1|12do kulat∞ch závorek. |0|12Dále následuje znak
 dvouteƒky, hodnota a st²edník, kter∞ cel∞ tento ²ádek uzav²e.
 |1|05Hodnoty je moºné p²i²azovat tímto slovem na jednom jediném ²ádku!
 |1|05(Nesmí b∞t rozd╪len na dva nebo více ²ádkà!)
 P²íklad:
 |1|09let(StrFa,StrOb,StrAdr,StrMi,StrTel) : '';
 do uveden∞ch prom╪nn∞ch bude vloºen prázdn∞ ²et╪zec.
 |1|09let(NumVyb,NumPol,SetPol) : 0;
 do uveden∞ch prom╪nn∞ch bude vloºena hodnota nula.

 |1|05 L.3 ü :loop>
 |1|05     ü :loop< .....;
    Zajistí p²edem neurƒen∞ poƒet opakování jednoduchého nebo sloºeného
 p²íkazu. P²íkaz se provede vºdy nejmén╪ jednou. P²íkaz :loop> obsahuje
 podobn╪ jako While, v∞raz kter∞ ²ídí opakované provád╪ní vno²eného
 p²íkazu. V∞raz musí b∞t standartního booleovského typu a vyhodnocuje
 se po provedení vno²eného p²íkazu. Provád╪ní vno²eného p²íkazu se opakuje
 tak dlouho, dokud není hodnota v∞razu True.
 P²íklad: |1|09:loop>
          |0|09   p²íkaz nebo p²íkazy
          |1|09:loop< |0|09v∞raz;

 Za slovem :loop> nebo :loop< màºeme uvést p²ípadnou poznámku k cyklu,
 kterou ukonƒíme dalτím znakem > (u :loop>) nebo < (u :loop<).
 P²íklad:|1|09:loop>|0|09ikony|1|09>
         |0|09   p²íkazy nebo p²íkaz
         |1|09:loop<|0|09ikony|1|09< |0|09v∞raz;

 |1|05 M.1  ü Main .......;
    Oznaƒuje název vlastní procedury. Za názvem procedury musí b∞t st²edník.
 Zaćtek procedury oznaĒme symbolem :> pro zaćtek a symbolem :< konce.
 P²íklad: |1|09Main |0|09Pocitani(Hod : integer);
          |0|09:>proc>
          |0|12    t╪lo procedury
          |0|09:<proc<

 |1|05 M.2  ü MainInside .......;
   Oznaƒuje název vloºené procedury v Main/Func. Za názvem procedury musí
 b∞t st²edník. Vloºená procedura MainInside màºe b∞t volána pouze v rámci
 procedury Main/Func. Zaćtek procedury oznaĒme symbolem pro zaćtek :>
 a konec symbolem pro konec :<
 P²íklad: |0|09Main Pocitani(Hod : integer);|0|12hlavní procedura
          |0|09variable
          |0|09  integer~ X;

          |1|09  MainInside |0|09Secti;             |0|12vloºená procedura
          |1|09  :>ins>                  |0|12zaƒátek vloºené procedury
          |1|09    obsah vloºené procedury
          |1|09  :<ins<                  |0|12konec vloºené procedury
          |1|09:>proc>                   |0|12zaƒátek hlavní procedury

          |0|09    t╪lo procedury
          |0|09:<proc<                   |0|12konec hlavní procedury

~16|1|05  N

 |1|05 N.1  ü .... next ....;
    Klíƒové slovo se pouºívá pro oznaƒení jednorázového ²eτení ve spojení
 se slovem if V∞raz next. Za slovem se uvede dalτí p²íkaz nebo volání
 procedury ƒi funkce. Pokud za V∞razem následuje skok na definovanou
 ƒást procedury/funkce, uvede se místo slova next slovo from. V p²ípad╪
 jednorázového p²i²azování hodnot do prom╪nn∞ch se místo slova next
 uvede slovo let.
 P²íklad pouºití:
    |0|09if Vyraz |1|09next |0|09Funkce;
    |0|09if Vyraz |1|09next |0|09Procedura;
 slovo next se neuvádí v p²ípad╪:
    |0|09if Vyraz |1|09from |0|09SkokVen;
    |0|09if Vyraz |1|09let |0|09Ret : 'Ahoj';

 |1|05 N.2  ü :note>
 |1|05      ü :note<
     N╪kdy se vyskytne pot²eba vloºit do zdrojového textu aplikace
 informaƒní text nebo poznámku, která obsahuje více ²ádkà. Pro tento
 úƒel slouºí klíƒové slovo :note> které oznaƒuje zaƒátek textu,
 kter∞ není zdrojem jazyka, ale pouze text. B╪ºn∞ text pak uvádíme
 na dalτích ²ádcích - nikoliv vedle slova :note> ! Cel∞ text pak
 ukonƒíme (op╪t na samostaném ²ádku) slovem :note<
    P²íklad:
    |0|09:note>
    |0|09  V t╪chto ²ádcích jsou uvedeneny
    |0|09  podrobn╪jτí pokyny pro obsluhu
    |0|09  této aplikace a pod.
    |0|09:note<
 Pokud se poznámka vejde na jeden jedin∞ ²ádek, pouºijete se
 klíƒové slovo |1|12rem> |0|12(viz. kapitola o rem>)


~16|1|05  O

 |1|05 O.1  ü OpenF@errlab(f,'soubor.xxx');
 |1|05      ü OpenF@errlab(f/v,'soubor.xxx');
 |1|05      ü OpenF(f,'soubor.xxx');
 |1|05      ü OpenF(f/v,'soubor.xxx');
    P²i²azuje jméno exertního diskového souboru a otev²e ho. P²edpokladem
 je jeho existence na disku. Pokud soubor neexistuje, operace nebude
 provedena aniº by doτlo k chyb╪. Pokud byl soubor jiº otev²en, nejprve
 se uzav²e a poté znovu otev²e. Po otev²ení se ukazatel v souboru nastaví
 na první poloºku. Informaci o tom, zda je soubor prázdn∞, získáme pomocí
 funkce Eof(f), která vrací logickou hodnotu TRUE, nebo pomocí funkce
 FileSize(f), která v tomto p²ípad╪ vrací nulu.
     Parametr "v" (velikost) je voliteln∞ a jedná se o v∞raz typu word.
 Màºe se definovat pouze tehdy, jedná-li se o soubor bez udaného typu.
 Parametr "v" (velikost) definuje velikost bloku, kter∞ se pouºívá p²i ƒtení
 dat ze souboru. U typov∞ch nebo textov∞ch souborà se parametr velikost
 n e u v á d í .
 V p²ípad╪, ºe je za slovem @ a je uvedeno jméno náv╪τtí, od kterého má
 program pokraƒovat v p²ípad╪ chyby, vypíτe se informaƒní okno s popisem
 a ƒíslem chyby, a program bude pokraƒovat od definovaného náv╪τtí.
 |1|05P²íkaz Assign se v tomto p²ípad╪ p²ed OpenF  n e u v á d í !
 |1|05Neuvádí se ani p²epínaƒ {$I-} a {$I+}, nebo ResOff a ResOn,
 |1|05které jsou jiº souƒástí tohoto p²íkazu. Pokud je za slovem @
 |1|05a je uvedeno náv╪τtí, bude program pokraƒovat v p²ípad╪ chyby
 |1|05od tohoto náv╪τtí. Podmínkou vτak je, ºe náv╪τtí je definováno
 |1|05klíƒov∞m slovem DefFrom, a ºe toto náv╪τtí skuteƒn╪ existuje!
 |1|05Musí b∞t za slovem #unit uvedena jednotka IOErrFB.

 |1|05 O.2  ü Other
   Slovo oznaƒuje konec jedné sekvence, po které bude následovat dalτí,
 která nabízí jinou moºnost ²eτení neº p²edeτlá. V podstat╪ to znamená,
 ºe pàvodní sekvence jeτt╪ dále pokraƒuje svou dalτí ƒástí. V klasickém
 Pascalu se tato sekvence ukonƒí slovem end (bez st²edníku) za kter∞m
 dále následuje slovo else a dalτí begin pro následující ƒást sekvence.
 Klíƒové slovo Other nahradí tato t²i slova. Slovo Other nelze pouºít
 v p²ípad╪ jednorázového ²eτení (next nebo let). Protoºe oznaƒuje pràb╪h
 z jedné sekvence do dalτí, |1|12nepouºívá se p²ed slovem dvouteƒka ani
symbol
 |1|12> nebo <.
 P²íklad:
    se slovem other a if Vyraz part   bez slova other a if Vyraz next
    |0|09Main Secti(x,y:integer);    |0|09Main Secti(x,y:integer);
    |0|09:>proc>                     |0|09:>proc>
    |0|09  if x < 10 part            |0|09  if x < 10 next
    |0|09    x == 10;                |0|09  :>
    |1|09  other                     |0|09    x == 10;
    |0|09    x < 10;                 |0|09  end
    |0|09  :if<x<                    |0|09   else
    |0|09:<proc                      |0|09  :>
                                |0|09    x < 10;
    Rozdíl je jist╪ patrn∞.     |0|09  :<
                                |0|09:<proc<

 |1|05 O.3 ü :OtherDo>
 |1|05     ü :Other<
    Toto klíƒové slovo nahrazuje dv╪ klíƒová slova souƒasn╪: -< a :>
 v Pascalu je to else begin. Proto je moºné takto stanovenou sekvenci
 ukonƒit ukonƒovacím slovem |1|12:other< |0|12nebo£ slovo :otherdo> je
 v podstat╪ slovem zahajovacím (zahajuje novou sekvenci). Takto zapoƒatá
 sekvence se màºe ukonƒit slovem :other<
 P²íklad:
 se slovem :otherdo>    bez slova :otherdo>     nebo
 |0|09if a = 336 next       |0|09if a = 336 next        if a = 336 next
 |0|09  let b:226           |0|09  let b:226               let b:226
 |1|09 :otherdo>            |0|09  else                   else
 |0|09  let b:228;          |0|09  :>                      :let>
 |0|09 let c:315;          |0|09   let b:228;              b:228;
 |1|09:other<               |0|09   let c:315;              c:315;
                       |0|09  :<                      :let<

 |1|05 O.4 ü :ToOther<
    Toto klíƒové slovo nahrazuje dv╪ klíƒová slova souƒasn╪: :< else
 v Pascalu je to end else. Je v podstat╪ slovem ukonƒovacím.
 P²íklad:
 se slovem :ToOther<      bez slova :ToOther<
 |0|09if a=336 part        |0|09if a=336 part
 |0|09  let b:228;         |0|09  let b:228;
 |0|09  let c:315;         |0|09  let c:315;
 |1|09:toother<            |0|09 end
 |0|09  let b:226;         |0|09 else
                          |0|09  let b:226;

~16|1|05  P

 |1|05 P.1  ü .... part
    Slovo oznaƒuje zaƒátek sekvence, která byla zapoƒata slovem if, for,
 while, case nebo with. Sekvence se ukonƒuje bu╘to ukonƒovacím slovem
 pro libovolnou sekvenci :part< a nebo ukoƒovacím slovem stejného
 v∞znamu jako poƒáteƒní slovo zahajující sekvenci (:if<, :for<, :while<,
 :case< nebo :with<).
 P²íklad pouºití slova part:    (ukonƒení slovem:)
   |1|12if Vyraz part             :if<
   |1|12for a,1/10 part           :for<
   |1|12while Vyraz part          :while<
   |1|12case Vyraz part           :case<
   |1|12with Vyraz part           :with<

 |1|05 P.2 ü Public     |1|12pro jednotky / unity
     Toto klíƒové slovo musí následovat za jménem jednotky. Urƒuje zaƒátek
 propojovací, neboli také ve²ejné ƒásti jednotky. Veτkeré deklarace, které
 se uvád╪jí v propojovací ƒásti jsou dostupné aplikaƒním programàm, které
 jednotku pouºívají.

~16|1|05  R

 |1|05 R.1  ü Read@errlab(f, data);
    Stejn╪ jako procedura Read(f,typprom) naƒte poloºku souboru do
 prom╪nné v operaƒní pam╪ti. Toto klíƒové slovo vτak upraví pàvodní
 proceduru Read tak, ºe zajistí odchycení p²ípadné chyby p²i ƒtení
 poloºky ze souboru, a vypíτe informaƒní okno s popisem a ƒíslem chyby.
 Program pak pokraƒuje od pozice uvedeného náv╪τtí. Náv╪τtí musí b∞t
 definováno za klíƒov∞m slovem DefFrom a musí skuteƒn╪ existovat.
 Za klíƒov∞m slovem #unit musí b∞t uvedena jednotka IOErrFB.
 P²íklad pouºití Read@errlab(f... :
 |0|09variable
 |0|09  file of word~FileWrd;
 |0|09  word~DataWrd;
 |1|09DefFrom EndProc;
 |0|09:>proc>
 |0|09  OpenF@EndProc(FileWrd,'SOUBOR.DTA');
 |0|12  pokud doτlo k chyb╪ p²i otev²ení souboru jdi na EndProc
 |0|09  :loop>
 |1|09    Read@ErrProc(FileWrd,DataWrd);
 |0|12    pokud doτlo k chyb╪ p²i ƒtení ze souboru jdi na ErrProc
 |0|09  :loop< Eof(FileWrd);
 |1|09  @ErrProc<
 |0|09  Close(FileWrd);
 |0|09  @EndProc<
 |0|09:<proc<

 |1|05 R.2  ü ReadLn@errlab(t, string);
    Stejn╪ jako procedura ReadLn(t,string) naƒte poloºku textového
 souboru. Toto klíƒové slovo vτak upraví pàvodní proceduru ReadLn tak,
 ºe zajistí odchycení p²ípadné chyby p²i ƒtení poloºky a vypíτe informaƒní
 okno s popisem a ƒíslem chyby. Program pak pokraƒuje od uvedeného náv╪τtí,
 které musí b∞t definováno za klíƒov∞m slovem DefFrom a musí skuteƒn╪
 existovat. Za slovem #unit musí b∞t uvedena jednotka IOErrFB.
 P²íklad pouºití ReadLn[errlab](t,... :
 |0|09variable
 |0|09  text~FileTxt;
 |0|09  string~Radek;
 |1|09DefFrom EndProc;
 |0|09:>proc>
 |0|09  OpenF@EndProc(FileTxt,'SOUBOR.TXT');
 |0|12  pokud doτlo k chyb╪ p²i otev²ení souboru jdi na EndProc
 |0|09  :loop>
 |1|09    ReadLn@ErrProc(FileTxt,Radek);
 |0|12    pokud doτlo k chyb╪ p²i ƒtení ze souboru jdi na ErrProc
 |0|09  :loop< Eof(FileTxt);
 |1|09  @ErrProc<
 |0|09  Close(FileTxt);
 |0|09  @EndProc<
 |0|09:<proc<


 |1|05 R.3 ü ResErr
    Zjiτ£uje stav IO operací pokud je v∞sledek ràzn∞ od nuly, doτlo
 k chyb╪.

 P²íklad:
  |0|09ResOff;     |0|12{p²i chyb╪ nebude program ukonƒen}
  |0|09OpenF(f,'TEST.FBS');  |0|12{ otev²ení souboru }
  |0|09if |1|09ResErr |0|09next exit; |0|12{ pokud je v∞sledek ràzn∞ od nuly, }
                             { ukonƒi tuto ƒást programu        }
  |1|09ResOn;      |0|12{ op╪t se kontroluje v∞sledek operací }

 |1|05 R.4 ü ResOk
    Zjiτ£uje stav IO operací pokud se v∞sledek rovná nule, nedoτlo
 k ºádné chyb╪.
 P²íklad: |1|09ResOff;
          |0|09OpenF(f,'TESTFB.FBS');
          |0|09If |1|09ResOk |0|09next Readln(f,Radek);
          |1|09ResOn;

 |1|05 R.5  ü RecordType = Ident
    Deklarace typu záznam, která se jinak uvádí po klíƒovém slov╪ type.
 V tomto p²ípad╪ se klíƒové slovo type neuvádí. Jako identifikátor se
 uvede oznaƒení záznamu. Proti p²edeτl∞m typov∞m deklaracím se parametry
 neuzavírají do hranat∞ch ani kulat∞ch závorek, ale uvád╪jí se od dalτího
 ²ádku podobn╪ jako za klíƒov∞m slovem variable nebo var. Celá deklarace
 se ukonĒ symbolem :<
 P²íklad : |1|09RecordType |0|09= Adresa
           |0|09    Jmeno : string[20];
           |0|09    Prijm : string[20];
           |0|09    Ulice : string[35];
           |1|09  :<adresa<

 |1|05 R.6  ü RenameF@errlab(f,'puvodni.xxx','novy.xxx');
 |1|05      ü RenameF(f,'puvodni.xxx','novy.xxx');
    P²i²azuje jméno externího diskového souboru. P²edpokladem je, ºe soubor
 na disku existuje. P²ejmenuje existující soubor puvodni.xxx nov∞m jménem
 definovan∞m parametrem novy.xxx. P²ejmenovat nelze jiº otev²en∞ soubor.
 V p²ípad╪, ºe za slovem je znak @ a je uvedeno jméno náv╪τtí, od kterého má
 program pokraƒovat v p²ípad╪ chyby, vypíτe se informaƒní okno s popisem
 a ƒíslem chyby, a program bude pokraƒovat od definovaného náv╪τtí.
 |1|05P²íkaz Assign se v tomto p²ípad╪ p²ed RenameF  n e u v á d í !
 |1|05Neuvádí se ani p²epínaƒ {$I-} a {$I+}, nebo ResOff a ResOn,
 |1|05které jsou jiº souƒástí tohoto p²íkazu. Pokud je za slovem @
 |1|05a je uvedeno náv╪τtí, bude program pokraƒovat v p²ípad╪ chyby
 |1|05od tohoto náv╪τtí. Podmínkou vτak je, ºe náv╪τtí je definováno
 |1|05klíƒov∞m slovem DefFrom, a ºe toto náv╪τtí skuteƒn╪ existuje!
 |1|05Musí b∞t za slovem #unit uvedena jednotka IOErrFB.

 |1|05 R.7 ü Replicate Jmeno(N) = (......);
 |1|05       Rep(Jmeno,N);
   Tímto p²íkazem se vytvo²í datové ²et╪zcové pole dle uvedeného
 parametru Jmeno o poƒtu poloºek dle parametru N. Jednotlivé poloºky
 tohoto pole se volají p²íkazem Rep(Jmeno,N). Poloºky tohoto pole
 jsou pevn╪ dány a lze je pouze ƒíst (nelze je m╪nit).
 P²íklad:
 |1|09Replicate |0|09Info(3) =
 |0|09  ('chyba p²i','opakovat znovu','Mám skuteƒn╪ zruτit ');
 |0|09  ......
 |0|09  WinInfoLine('Zjiτt╪na '+|1|09Rep(Inf,1)|0|09+' naƒítání');
   nebo
 |0|09  WinInfoLine('Chcete '+|1|09Rep(Inf,2)|0|09+' funkci ?');
   nebo
 |0|09  WinInfoLine(|1|09Rep(Inf,3)|0|09+' tento soubor ?');
   a pod.

 |1|05 R.8 ü ResOff;
    Lokální p²epínaƒ, kter∞ ²ídí generování p²ídavného kódu, kter∞
 kontroluje v∞sledek V/V operací. P²i uvedení p²íkazu ResOff se
 musí kontrolovat v∞sledek prost²ednictvím funkce IfResErr nebo IfResOk.
 Toto klíƒové slovo se pouºívá pouze ve spojení s pascalovsk∞mi slovy
 pro práci se soubory. U klíƒov∞ch slov TFB se jiº nepouºívají, nebo£
 vτechny p²íkazy pro práci se soubory je mají jiº zabudovány.

 |1|05 R.9 ü ResOn;
    Lokální p²epínaƒ, kter∞ ²ídí generování p²ídavného kódu, kter∞
 kontroluje v∞sledek V/V operací. P²i uvedení p²íkazu ResOn se
 hlásí chyby V/V operací automaticky a provád╪n∞ program se ukonƒí.
 Toto klíƒové slovo se pouºívá pouze ve spojení s pascalovsk∞mi slovy
 pro práci se soubory. U klíƒov∞ch slov TFB se jiº nepouºívají, nebo£
 vτechny p²íkazy pro práci se soubory je mají jiº zabudovány.

 |1|05 R.10 ü rem>
    Toto slovo oznaƒuje zaƒátek poznámky na ²ádku. Poznámka màºe
 b∞t uvedena za libovoln∞m p²íkazem, ale za poznámkou jiº nesmí
 následovat ºádn∞ p²íkaz nebo klíƒové slovo. Slovo rem> totiº
 oznaƒí od pozice jeho umíst╪ní na ²ádku dalτí text aº na úpln∞
 konec ²ádku jako pouhou poznámku. Proto za tímto slovem jiº
 nesmí následovat jiné klíƒové slovo nebo p²íkaz.
    P²íklad:
    |1|05InitFB;  rem> inicializace grafického reºimu
  nebo
    |1|05for n,1/9 part  rem> cyklus od 1 do 9
  a pod.

~16|1|05  S

 |1|05 S.1  ü Stand   |1|12pouze v jednotce / unit╪
    Tímto klíƒov∞m slovem zaƒíná implementaƒní ƒást, která màºe obsahovat
 dalτí deklarace konstant, prom╪nn∞ch, definice typà. Deklarace v imple-
 mentaƒní ƒásti nejsou p²edm╪tem exportu z jednotky a nejsou p²ístupné
 z programu, kter∞ jednotku pouºívá. Implementaƒní ƒást obsahuje t╪la
 procedur a funkcí, kaºdá procedura nebo funkce se uvádí sv∞m jménem
 a parametry. Implementaƒní ƒást se ukonƒuje klíƒov∞m slovem EndFo
 nebo màºe konƒit tzv. inicializaƒní ƒástí tak, ºe p²ed EndFo vloºíme
 Follow. Mezi temito klíƒov∞mi slovy pak napíτeme vlastní iniciali-
 zaƒní program.

 |1|05 S.2  ü SetOpenF@errlab(f,'soubor.xxx'>odkud);
 |1|05      ü SetOpenF@errlab(f/v,'soubor.xxx'>odkud);
 |1|05      ü SetOpenF(f,'soubor.xxx'>odkud);
 |1|05      ü SetOpenF(f/v,'soubor.xxx'>odkud);
    P²i²azuje jméno exertního diskového souboru a otev²e ho. Ukazatel
 první pozice v souboru bude nastaven na základ╪ parametru |1|0odkud
 (nahrazuje slovo seek, které se v tomto p²ípad╪ jiº neuvádí).P²edpokladem
 je jeho existence na disku. Pokud soubor neexistuje, operace nebude
 provedena aniº by doτlo k chyb╪. Pokud byl soubor jiº otev²en, nejprve
 se uzav²e a poté znovu otev²e. Po otev²ení se ukazatel v souboru nastaví
 na první poloºku. Informaci o tom, zda je soubor prázdn∞, získáme pomocí
 funkce Eof(f), která vrací logickou hodnotu TRUE, nebo pomocí funkce
 FileSize(f), která v tomto p²ípad╪ vrací nulu.
     Parametr "v" (velikost) je voliteln∞ a jedná se o v∞raz typu word.
 Màºe se definovat pouze tehdy, jedná-li se o soubor bez udaného typu.
 Parametr "v" (velikost) definuje velikost bloku, kter∞ se pouºívá p²i ƒtení
 dat ze souboru. U typov∞ch nebo textov∞ch souborà se parametr velikost
 n e u v á d í .
 V p²ípad╪, ºe za znakem @ je uvedeno jméno náv╪τtí, od kterého má
 program pokraƒovat v p²ípad╪ chyby, vypíτe se informaƒní okno s popisem
 a ƒíslem chyby, a program bude pokraƒovat od definovaného náv╪τtí.
 |1|05P²íkaz Assign se v tomto p²ípad╪ p²ed SetOpenF  n e u v á d í !
 |1|05Neuvádí se ani p²epínaƒ {$I-} a {$I+}, nebo ResOff a ResOn,
 |1|05které jsou jiº souƒástí tohoto p²íkazu. Pokud je za slovem znak @
 |1|05a je uvedeno náv╪τtí, bude program pokraƒovat v p²ípad╪ chyby
 |1|05od tohoto náv╪τtí. Podmínkou vτak je, ºe náv╪τtí je definováno
 |1|05klíƒov∞m slovem DefFrom, a ºe toto náv╪τtí skuteƒn╪ existuje!
 |1|05Musí b∞t za slovem #unit uvedena jednotka IOErrFB.
 |1|05POZOR ! P²íkaz SetOpenF se nesmí pouºít u souborà typu text.

 |1|05 S.3  ü StrPos(HRet,PRet) ....;
 |1|05      ü StrPos(HRet,PRet) from ....;
 |1|05      ü StrPos(HRet,PRet) let ....;
 |1|05      ü StrPos(HRet,PRet) part
     Funkce zjiτ£uje, zda hledan∞ ²et╪zec HRet je obsaºen v pàvodním
 ²et╪zci PRet. Zjiτt╪ní vrací jako hodnotu typu boolean TRUE. Za p²íkazem
 musí b∞t uveden dalτí |1|12p²íkaz |0|12(název procedury) nebo klíƒové
 slovo |1|12from |0|12za kter∞m následuje jméno náv╪τtí, dále klíƒové slovo
 |1|12let |0|12za kter∞m následuje p²i²azování hodnot do prom╪nn∞ch, nebo
 slovo |1|12part |0|12které oznaƒuje zaƒátek nové sekvence.
 |1|05Mezi následn∞mi klíƒov∞mi slovy nebo p²íkazy se nesmí pouºít slovo
next.
 P²íklady:
   |1|12StrPos('tel',PRet) let PRet : PRet + 'tel';
   |1|12StrPos('tel',PRet) from JdiDale;
   |1|12StrPos('tel',PRet) NapisTo;
  nebo
   |1|12StrPos('tel',PRet) part
   |1|12   ...........
   |1|12   ...........
   |1|12:part<pos<

 |1|05 S.4  ü StrNotPos(HRet,PRet) ....;
 |1|05      ü StrNotPos(HRet,PRet) from ....;
 |1|05      ü StrNotPos(HRet,PRet) let ....;
 |1|05      ü StrNotPos(HRet,PRet) part
     Funkce zjiτ£uje, zda hledan∞ ²et╪zec HRet je obsaºen v pàvodním
 ²et╪zci PRet. Zjiτt╪ní vrací jako hodnotu typu boolean FALSE. Za p²íkazem
 musí b∞t uveden dalτí |1|12p²íkaz |0|12(název procedury) nebo klíƒové
 slovo |1|12from |0|12za kter∞m následuje jméno náv╪τtí, dále klíƒové slovo
 |1|12let |0|12za kter∞m následuje p²i²azování hodnot do prom╪nn∞ch, nebo
 slovo |1|12part |0|12které oznaƒuje zaƒátek nové sekvence.
 |1|05Mezi následn∞mi klíƒov∞mi slovy nebo p²íkazy se nesmí pouºít slovo
 |1|05next.
 P²íklady:
   |1|12StrNotPos('tel',PRet) let PRet : PRet + 'tel';
   |1|12StrNotPos('tel',PRet) from JdiDale;
   |1|12StrNotPos('tel',PRet) NapisTo;
 nebo
   |1|12StrNotPos('tel',PRet) part
   |1|12   ...........
   |1|12   ...........
   |1|12:part<pos<


~16|1|05  T
 |1|05 T.1 ü #Translation
 |1|05 T.2 ü #NoTranslation
      Protoºe sekvenƒní a jednorázová klíƒová slova TFBPRO nelze
 kombinovat se slovy TP ani ASM (assembleru), |1|12je nutné pouºít
 |1|12tuto direktivu p²ekladaƒe pro tu ƒást zdrojového textu, která
 |1|12bude obsahovat klíƒová slova a p²íkazy TP nebo ASM.
      Umíst╪ní slova |1|12#NoTranslation |0|12p²ed ƒást zdrojového textu,
 kter∞ obsahuje p²íkazy a klíƒová slova jazyka Turbo Pascal nebo
 Assembleru, zpàsobí, ºe |1|12p²ekladaƒ tyto p²íkazy ponechá v pàvodním
 |1|12zn╪ní, ve kterém je p²edá kompilátoru.
      Pro ƒást zdrojového textu, kter∞ bude dále obsahovat
 klíƒová slova a p²íkazy TFBPRO se po ƒásti oznaƒené #NoTranslation
 musí pouºít slovo |1|12#Translation, |0|12které p²ekladaƒi naznaƒí, ºe
následn∞
 zdrojov∞ text je jiº op╪t psán v jazyce TFBPRO a je povoleno jeho
 p²eloºení pro kompilátor.

~16|1|05  U

 |1|05 U.1 ü #unit
    Uvádí se seznam jednotek .FBL, které bude program pouºívat. Seznam
 màºe b∞t uveden i v jednotce, která màºe pouºívat jiné jednotky.
 P²íklad: program:                     jednotka:
          |1|12//Jmeno//                \\Jmeno\\
          |1|12Heap <4000,0,0>          Public
          |1|09#unit |1|12Dos, GraphFb;      |1|09#unit |1|12GraphFB;

~16|1|05  V

 |1|05 V.1  ü variable
    Pouºívá se pro deklaraci prom╪nn∞ch ordninálních typà.|1|09 Za tímto
 |1|09klíƒov∞m slovem nesmí b∞t ºádná jiná klíƒová slova nebo p²íkazy.
 Vyjímku tvo²í pouze poznámka uvedená ve sloºen∞ch závorkách {}, která
 vτak nesmí obsahovat tento znak ~.
    Deklarace prom╪nn∞ch se uvád╪jí na dalτích ²ádcích. Název typu se
 ukonƒí znakem ~, za kter∞m se uvedene jméno nebo jména prom╪nn∞ch.
 Základním pravidlem je: uvedení typu ukonƒeného znakem~jméno prom╪nné.
 Pokud je prom╪nn∞ch stejného typu více (proto bylo toto slovo zavedeno),
 uvedou se za typem odd╪lené ƒárkou. Celá deklarace musí b∞t ukonƒena
 st²edníkem.
 P²íklad:
        |1|09variable
        |1|09  string~ |0|09NRet, Nazev, Hlavicka, Heslo;
        |1|09  word~   |0|09GetD, Delka;
        |1|09  file of byte~ |0|09f, fp, souf;
        |1|09  integer~ |0|09X, Y, X2, Y2;
        |1|09  Declare : Pole[1-10/string[15]];
                                      a pod.
 |1|09Za slovem Declare jiº nesm╪jí b∞t uvedeny ºádné samostané deklarace!
 |0|09Pokud pouºijete jako klíƒové slovo pouze |1|09var |0|09neuvádí se za
 |0|09typem prom╪nné znak ~ . V takovém p²ípad╪ by kompilátor ohlásil chybu.
 |1|09Znak ~ se neuvádí ani za slovem Declare.
 |0|09Klíƒové slovo variable se nesmí pouºít pro deklaraci prom╪nn∞ch v názvu
 |0|09procedury (Main, MainInside) a funkce (Func, FuncInside), kde se
 |0|09pouºívá klíƒové slovo |1|09var.
 |1|09správn╪: Main Procedura(var x,y:integer);
 |1|12chybn╪:  Main Procedura(variable integer~x,y);

~16|1|05  W

 |1|05 W.1 ü with vyraz part
 |1|05     ü :with<
    P²íkaz zajistí zkrácen∞ postup odkazování na poloºky záznamu. Uvnit²
 p²íkazu lze provád╪t odkazy na poloºky záznamu pouze identifikátorem
 poloºky, není nutné uvád╪t idetifikátor poloºky.
      |1|12 With prom╪ná typu záznam part
 V argumentu p²íkazu With se musí pouºít identifikátor prom╪nné typu
 záznam. Vno²en∞m p²íkazem b∞vá v╪tτinou sloºen∞ p²íkaz. Pouºití p²íkazu
 si ukáºeme na p²íklad╪ typu Registers, kter∞ se deklaruje ve standartní
 jednotce DOS:
      |1|12variable
      |1|12   Registers~ Reg;
      |1|12:>proc>
      |1|12  Reg.AX == ...|0|12odkaz na registr AX bez p²íkazu With
      |1|09  with |0|09Reg |1|09part
      |1|12    AX == ...  |0|12odkaz na registr AX v p²íkazu DoWith
      |1|09  :with<|0|09reg|1|09<
      |1|12:<proc<
 Uvnit² p²íkazu With se u kaºdého odkazu na prom╪nnou nejprve kontroluje
 zda se màºe interpretovat jako poloºka záznamu. Je-li to moºné, pak se
 vºdy takto interpretuje, i kdyº je souƒasn╪ dostupná prom╪nná se stejn∞m
 jménem,
      |1|12RecordType = Bod
      |1|12       X,Y : integer;
      |1|12     end;
      |1|12variable
      |1|12   integer~ X, Y;
      |1|12   Bod~ B;
      |1|12:>proc>
      |1|09  With |0|09B |1|09part
      |1|12    let X : 5;
      |1|12    let Y : 8;
      |1|09  :with<|0|09B|1|09<
      |1|12:<proc<
 Poznámka: X a Y màºe odkazovat na prom╪nné nebo na sloºky záznamu typu
 Bod. Protoºe jsou p²i²azovací p²íkazy vno²en∞m p²íkazem p²íkazu With
 provádí se automaticky odkaz na poloºky záznamu, i kdyº existují
 prom╪nné stejného jména.
     P²íkaz With se màºe pouºít za stejn∞ch podmínek i na instancích
 typu objekt. V p²ípad╪ OOP se vτak jedná o technologickou chybu p²i
 v∞stavb╪ programu, i kdyº p²ekladaƒ nehlásí chybu zápisu ani logickou
 chybu b╪hu programu.
 Konec této sekvence ukonƒíme klíƒov∞m slovem :with< do kterého màºeme
 vloºit p²ípadnou poznámku, kterou ukonƒíme dalτím znakem < a jiº
 neuvádíme znak st²edníku.

 |1|05 W.2  ü  while vyraz part
 |1|05      ü  :while<
     P²íkaz zajistí p²edem neurƒen∞ poƒet opakování jednoduchého nebo
 sloºené p²íkazu.
 P²íklad:|1|12variable
         |1|12  integer~ i;
         |1|09While |0|09i < 100 |1|09part  |0|12{ dokud je i menτí neº 100}
         |1|12  Inc(i);
         |1|09:while<|0|09i|1|09<

 |1|05 W.3  ü WipeF@errlab(f,'puvodni.xxx');
 |1|05      ü WipeF(f,'puvodni.xxx');
    P²i²azuje jméno externího diskového souboru urƒeného pro zruτení
 (smazání z disku). P²edpokladem je, ºe soubor na disku existuje.
 Pokud soubor neexistuje, nebude operace provedna aniº by doτlo k chyb╪.
 V p²ípad╪, ºe je za slovem @ a je uvedeno jméno náv╪τtí, od kterého má
 program pokraƒovat v p²ípad╪ chyby, vypíτe se informaƒní okno s popisem
 a ƒíslem chyby, a program bude pokraƒovat od definovaného náv╪τtí.
 Pokud je soubor jiº otev²en∞, nejprve se uzav²e a poté se op╪t otev²e.
 |1|05P²íkaz Assign se v tomto p²ípad╪ p²ed WipeF  n e u v á d í !
 |1|05Neuvádí se ani p²epínaƒ {$I-} a {$I+}, nebo ResOff a ResOn,
 |1|05které jsou jiº souƒástí tohoto p²íkazu. Pokud je za slovem znak @
 |1|05a je uvedeno náv╪τtí, bude program pokraƒovat v p²ípad╪ chyby
 |1|05od tohoto náv╪τtí. Podmínkou vτak je, ºe náv╪τtí je definováno
 |1|05klíƒov∞m slovem DefFrom, a ºe toto náv╪τtí skuteƒn╪ existuje!
 |1|05Musí b∞t za slovem #unit uvedena jednotka IOErrFB.


 |1|05 W.5  ü Write@errlab(f, data);
   Stejn╪ jako procedura Write(f,data) zapíτe prom╪nnou do souboru.
 Voliteln∞ parametr f je prom╪nná typu soubor a parametr data jsou
 jednotlivé poloºky souboru, kter∞ musí odpovídat typu jedné sloºky
 souboru. Mohou b∞t typu char, integer, real, ²et╪zec nebo boolean.
 Klíƒové slovo Write@ upravuje tuto proceduru tak, ºe odchytí
 p²ípadnou chybu p²i ƒtení ze souboru, a pokraƒuje od definovaného
 náv╪τtí za znakem @. Náv╪τtí musí definováno za klíƒov∞m slovem
 DefFrom a musí skuteƒn╪ existovat.
 Za klíƒov∞m slovem #unit musí b∞t uvedena jednotka IOErrFB.
 P²íklad pouºití:
 |1|12variable
 |1|12  file of word~FileWrd;
 |1|12  word~DataWrd;
 |1|09DefFrom EndProc;
 |1|12:>proc>
 |1|12  OpenF@EndProc(FileWrd,'SOUBOR.DTA');
 |0|12  pokud doτlo k chyb╪ p²i otev²ení souboru jdi na EndProc
 |1|12  :loop>
 |1|09    Write@ErrProc(FileWrd,DataWrd);
 |0|12    pokud doτlo k chyb╪ p²i ƒtení ze souboru jdi na ErrProc
 |1|12  :loop< Eof(FileWrd);
 |1|09  @ErrProc<
 |1|12  Close(FileWrd);
 |1|12  @EndProc<
 |1|12:<proc<

 |1|05 W.6  ü WriteLn@errlab(t, string);
   Stejn╪ jako procedura WriteLn(t,string) zapíτe prom╪nnou do souboru.
 Procedura se màºe pouºít pouze pro zápis do textov∞ch souborà.
 Klíƒové slovo WriteLn@ upravuje tuto proceduru tak, ºe odchytí
 p²ípadnou chybu p²i ƒtení ze souboru, a pokraƒuje od uvedeného
 náv╪τtí, které musí b∞t definováno za klíƒov∞m slovem DefFrom
 a musí skuteƒn╪ existovat.
 P²íklad pouºití:
 |1|12variable
 |1|12  text~FileTxt;
 |1|12  string~Radek;
 |1|09DefFrom EndProc;
 |1|12:>proc>
 |1|12  OpenF@EndProc(FileTxt,'SOUBOR.TXT');
 |0|12  pokud doτlo k chyb╪ p²i otev²ení souboru jdi na EndProc
 |1|12  :loop>
 |1|09    WriteLn@ErrProc(FileTxt,Radek);
 |0|12    pokud doτlo k chyb╪ p²i ƒtení ze souboru jdi na ErrProc
 |1|12  :loop< Eof(FileWrd);
 |1|09  @ErrProc<
 |1|12  Close(FileTxt);
 |1|12  @EndProc<
 |1|12:<proc<