Rozšíření Free Pascalu - Builder.cz - Informacni server o programovani

22. června 2001, 00.00 | Tímto článkem zahajujeme nový seriál o Free Pascalu. V tomto dílu se podíváme na jeho rozšíření oproti "klasice" - Turbo/Borland Pascalu a Delphi.

Jelikož článek Free Pascal FAQ, vydaný před časem na Builderu, vzbudil mezi čtenáři celkem slušný ohlas (alespoň soudě podle jeho čtenosti), rozhodl jsem se tématu Free Pascal zasvětit celý seriál. První díl bude věnován jeho rozšířením oproti Turbo/Borland Pascalu (dále jen TP) a Delphi, další pak editoru FPE, který je určen právě pro editaci zdrojových kódů Free Pascalu. Další směrování seriálu můžou samozřejmě ovlivnit i čtenáři - od toho tu konec konců máme diskuze pod články, popř. můžete psát i na můj mail. Tak, ale teď už k článku samotnému:

Pro ty, co první článek o programu Free Pascal Compiler (dále FPC) nečetli, malé připomenutí: FPC je otevřený projekt, který má za cíl vytvořit multiplatformní 32-bitový kompilátor kompatibilní s Turbo/Borland Pascalem a implementovat do něj i některá rozšíření. No a o těch se nyní budeme bavit.

Rozšíření FPC se dají rozdělit na dva výrazné typy - inspirovaná Delphi a inspirovaná jazyky C/C++. Místy se tyto skupiny trochu překrývají (vývojáři Delphi se totiž sem tam také inspirovali céčkem), ale to nám příliš nevadí. Podívejme se tedy na první skupinu:

Největším rozšířením oproti TP je nejspíš 32-bitovost celého kompilátoru. Tím pádem odpadají problémy, které byly typické pro 16-bitové kompilátory: segmentace paměti a její obtížný management (hlavně pokud jste se nespokojili se základními 640 kB) a omezená velikost datových struktur (do 64 kB). Ve FPC máte k dispozici celý 32-bitový adresový prostor (samozřejmě limitovaný dostupným množstvím paměti a použitým operačním systémem).

Z prvního odstavce takřka vyplývá i druhé rozšíření - dlouhé řetězce (long strings). V TP jste byli omezeni 255 znaky, ve FPC jen možnostmi 32-bitového adresování. Dlouhé řetězce jsou stejně jako v Delphi realizovány jako reference-counted (u každého řetězce se tedy počítá, kolikrát je v programu používán, a když toto číslo dosáhne nuly, je řetězec odstraněn z paměti) a kopírování probíhá schématem copy-on-write (fyzické kopírování řetězců v paměti např. při přiřazení nastává až ve chvíli, kdy je jeden z nich změněn).

Dalším rysem podporovaným FPC jsou objekty. Myslím tím teď objekty deklarované pomocí klíčového slova class, nikoliv "objekty" v TP deklarované přes object (i když ty FPC v zájmu kompatibility podporuje také). Implementace je opět kompatibilní s Delphi, tzn. výchozí třídou je TObject, od které můžete odvozovat celou objektovou hierarchii.

Samozřejmostí, často používanou v Delphi, jsou vyjímky (exceptions). I ty byly implementovány ve FPC a používají se úplně stejně jako v Delphi.

Další věcí převzatou z novějších verzí Delphi je přetěžování funkcí (function overloading). Jak tato věc funguje, nejlépe pochopíte z příkladu:

// funkce, převádějící svůj parametr na řetězec

function AsString(I: Integer): String;
begin
  AsString := IntToStr(I);
end;

function AsString(D: Double): String;
begin
  AsString := FloatToStr(D);
end;

Pro přetěžované funkce platí jednoduchá pravidla: Musí se lišit typem parametrů (odlišení jen různým typem výsledku nestačí) a pokud jednu z přetížených funkcí exportujeme z unity (tzn. napíšeme její deklaraci do sekce interface), musíme exportovat i všechny ostatní stejného názvu - jinak se dočkáme chybového hlášení od kompilátoru.

Když už jsme u funkcí - podporovány jsou všechny důležité volací konvence jako v Delphi - tzn. register, pascal, stdcall a cdecl.

Posledním významným Delphi-like rozšířením je implementace některých unit, jako SysUtils, Classes, Math, Windows apod. V programech tedy můžete tedy bez problémů používat třídy jako TStringList, TList, funkce pro formátování textu (Format, IntToStr, IntToHex...) a jiné. Většinu objektů Delphi, které se přímo netýkají vizuální stránky aplikace (jinými slovy - téměř vše, co není odvozeno od TComponent), má programátor ve FPC plně k dispozici.

FPC podporuje čtyři nové operátory, které docela pomohou zkrátit (a někdy také znepřehlednit) zdrojový kód. Jsou to +=, -=, *= a /=. Jejich použití je stejné jako v C/C++, např. příkaz A += 1 zvedne hodnotu proměnné A o jedničku.

U operátorů ještě chvíli zůstaneme, protože dalším rozšířením FPC je přetěžování operátorů (operator overloading). Stejně jako u přetěžování funkcí, nejlépe vše osvětlí příklad:

// nový typ "komplexní číslo" s reálnou a imaginární částí
type
  TComplex = record
    R: Double;
    I: Double;
  end;

// definice sčítání dvou komplexních čísel
oparator + (Z1: TComplex; Z2: TComplex) Result: TComplex;
begin
  Result.R := Z1.R + Z2.R;
  Result.I := Z1.I + Z2.I;
end;

Dalším užitečným rozšířením je vylepšená práce s direktivami kompilátoru, přesněji řečeno s direktivou {$define}. Můžeme zde totiž používat makra, obdobně jako v C/C++. Opět malý příklad:

{$define Distance := Sqrt(Sqr(X) + Sqr(Y)):7:2 }

X := 3;
Y := 4;
WriteLn(Distance) // vypíše 5.00

Bohužel, makra ve FPC neumožňují používání parametrů, takže na výrazy typu céčkovského #define Max(a, b) ((a) > (b) ? (a) : (b)) si musíme zatím nechat zajít chuť. Snad ale bude tato vlastnost do FPC brzy doplněna (spolu s ternárním podmínkovým operátorem :-).

Další možností je používání základních operátorů u direktivy {$if}, díky čemuž se dají tvořit poměrně složité podmínky při podmíněné kompilaci. Používat můžeme všechny základní aritmetické a logické operátory Pascalu.

Možností převzatou z překladače GCC (GNU C Compiler) je tzv. AT&T syntaxe inline assembleru. Normálním pascalistům tato možnost nejspíš bude k ničemu, ale céčkařům pracujícím právě v GCC to přijde vhod. Samozřejmě kdo chce, může programovat v "konvenčním" assembleru.

Takřka všechna rozšíření FPC se dají aktivovat či potlačit příslušnými direktivami kompilátoru nebo parametry příkazové řádky. Jejich vyčerpávající popis najdete v dokumentaci k FPC. Jelikož je ale trochu problém pamatovat si všechny defaultní hodnoty různých nastavení a pak je direktivami měnit v každém programu, vymysleli tvůrci FPC direktivu {$mode}. S její pomocí můžete přejít do režimu Delphi ({$mode Delphi}), Turbo Pascalu ({$mode TP}), GNU Pascalu ({$mode GPC}) a nebo defaultního módu FPC ({$mode FPC} popř. {$mode FPCOBJ}). V každém z režimů je co nejvěrněji emulovaná dané verze Pascalu včetně drobných změn v syntaxi a jejích omezení. Většina rozšíření je samozřejmě dostupná jen z módů FPC a FPCOBJ.

Jak je snad z článku vidět, autoři FPC na rozšířeních opravdu nešetřili, navíc všechna rozšíření jsou velice praktická a pro programátora užitečná. Někdy si říkám: Kéž by podobně uvažoval Borland. Minimálně přetěžování operátorů a makra by totiž Delphi vůbec neublížily - ba naopak.