P R A H A2012

Následující text vznikl jako součást osobní webové stránky autora:

http://people.fsv.cvut.cz/~svobodal/

© Doc. Ing. Luboš Svoboda, CSc. 2012

- 2 -

- 3 -

O autorovi

Doc. Ing. Luboš Svoboda, CSc. (* 1947) pracoval přes dvacet let ve výzkumu nových stavebních hmot a následně zhruba stejnou dobu působil na fakultě stavební Českého vysokého učení technického v Praze, kde vyučoval předměty s materiálovou tématikou a v letech 1998 – 2006 vedl katedru stavebních hmot.

Jako externí učitel dodnes přednáší na fakultě chemicko-technologické Univerzity Pardubice. Vedle své pedagogické práce a vedle výzkumu, zaměřeného na optimální skladbu kompozitních materiálů, se dlouhodobě zabývá problematikou příležitostného programování a vlastní tvorbou počítačových programů.

- 4 -

Abstrakt

PureBasic pocházející z francouzské firmy Fantaisie Software je koncipován jako jednoduchý a snadno zvládnutelný programovací jazyk. Původně byl vytvořen k programování her na domácích počítačích Amiga, ale vývoj dalších verzí pro osobní počítače byl provázen výrazným rozšířením jeho aplikační způsobilosti. Soudobý PureBasic je univerzálně využitelný jako vyzrálý a vysoce výkoný programovací prostředek.

Stejný zdrojový kód napsaný v PureBasic může být použit v různých operačních prostředích (Windows XP 32-bit, Windows XP Professional x64 Edition, Windows Vista 32-bit, Windows Vista 64-bit, MAC OS X a Linux). Díky uživatelsky přátelské procedurální koncepci je PureBasic mimořádně vhodný pro příležitostné programátory.

Kniha „Překvapivý PureBasic“ je informativní studie věnovaná tomuto pozoruhodnému, ale dosud málo známému produktu.

V textu obsažené příklady předvádějí PureBasic hlavně jako nástroj pro pohodlný vývoj malých a středních výpočetních aplikací přizpůsobených specifickým uživatelským potřebám.

K celkovému hodnocení jazyku je použita SWOT analýza provedená z pohledu budoucího uživatele.

Abstract

PureBasic coming from French firm Fantaisie Software is intended as simple and easy manageable programming language. Originally it was created at game programming on Amiga home computers, but development of next versions for personal computers led to distinctive enlargement of PureBasic abilities. Current PureBasic is all-purpose exploitable as high-powered programming tool.

Same source code which is written in PureBasic can be used in different operational systems (Windows XP 32-bit, Windows XP Professional x64 Edition, Windows Vista 32-bit, Windows Vista 64-bit, MAC OS X and Linux). Thanks to user friendly procedural conception, PureBasic is extraordinarily suitable for casual programmers.

The book ˝Surprising PureBasic˝ is an informative study dedicated to this remarkable, but so far little known product.

Examples given in text show PureBasic mainly as a tool for comfortable development of small and medium computational applications adapted for specific needs of users.

Overall evaluation of language is done by SWOT analysis performed from point of view of a future user.

- 5 -

Obsah

Předmluva..........................................................................................................................7

1. Historie PureBasic......................................................................................................9

2. Pořízení PureBasic.......................................................................................................18

3. Instalace PureBasic......................................................................................................21

4. Struktura a základní syntaxe.......................................................................................26

4.1 Aritmetické a logické operátory.............................................................................27

4.3 Psaní čísel...............................................................................................................29

4.4 Klíčová slova..........................................................................................................29

4.5 Uživatelské názvy..................................................................................................29

4.7 Větvení a cykly......................................................................................................33

4.8 Matematické funkce...............................................................................................34

4.9 Uživatelské procedury a funkce.............................................................................35

4.10 Makropříkazy.......................................................................................................37

4.11 Práce s řetězci......................................................................................................38

4.12 Speciální příkazy..................................................................................................41

5. Rozhraní a I/O operace.................................................................................................43

5.1 Textový výstup......................................................................................................43

5.1.1 Výstup na obrazovku.......................................................................................43

5.1.2 Výstup do souboru..........................................................................................52

5.1.3 Výstup na tiskárnu...........................................................................................53

5.2 Alfanumerický vstup..............................................................................................54

5.2.1 Vstup z klávesnice...........................................................................................54

5.2.2 Vstup s pomocí myši.......................................................................................60

5.2.3 Vstup ze souboru.............................................................................................60

5.2.4 Import dat........................................................................................................64

5.3 Grafický výstup......................................................................................................66

5.4 Tvorba vlastních knihoven.....................................................................................67

5.5 Ladění a ošetření chyb............................................................................................67

6. Používání PureBasic.....................................................................................................68

6.1 Vyčíslení v IDE......................................................................................................69

- 6 -

6.2 Drobné utility.........................................................................................................70

6.3 Malé programy......................................................................................................71

6.4 Programy střední velkosti.......................................................................................78

6.5 Rozsáhlé úlohy.......................................................................................................79

7. Celkové hodnocení.......................................................................................................80

7.1 Silné stránky...........................................................................................................81

7.2 Slabé stránky..........................................................................................................83

7.3 Příležitosti...............................................................................................................83

7.4 Hrozby....................................................................................................................84

8. Závěr............................................................................................................................86

9. Literatura......................................................................................................................87

- 7 -

Předmluva

Typickou programovou výbavu soudobých osobních počítačů tvoří operační systém, internetový prohlížeč, poštovní klient, antivirový software a nějaký obecně použitelný kancelářský balík, který kromě textového a prezentační programu zpravidla obsahuje i tabulkový

kalkulátor. Tabulkový kalkulátor často slouží k tvorbě menších databází při potřebě větší databáze bývá přítomen i databázový program.

Vzhledem k šíři a proměnnosti problematiky řešené na různých pracovištích a vzhledem k různým potřebám jednotlivých uživatelů toto základní programové vybavení téměř nikdy nepostačuje a je doplňováno dalšími veřejně nabízenými komerčními programy (např. programem grafickým, databázovým, typografickým, fakturačním). Kromě toho si uživatelé často doplňují programové vybavení o různé volně dostupné utility.

Ani všechny tyto programy však nepokrývají uživatelské požadavky beze zbytku a vzniká tak potřeba tvorby aplikačního software určeného přímo k  řešení konkrétních problémů a úloh.

Specifický aplikační software může být zajišťován profesionálními programátory, kteří spolupracují s budoucími uživateli programu a realizují jejich požadavky. V případě programů jejichž používání je omezeno jen na úzký okruh uživatelů (nebo dokonce jen na jednoho uživatele) je však takovýto postup málo operativní a neúměrně nákladný.

Otvírá se tak prostor pro příležitostné programátory, kteří provádějí vývoj aplikačního software k podpoře své hlavní profesní činnosti a pro svou osobní potřebu vůbec. K takové činnosti ovšem potřebují vhodný programovací jazyk.

Soudobé programovací jazyky používané profesionálními programátory jsou pro příležitostné programátory nevhodné. Jejich zvládnutí není krátkodobou záležitostí a nezbytná časová investice těžko může být zhodnocena, pokud nebude využívána při každodenní programátorské práci.

Má-li být tvorba příležitostného programátora prakticky úspěšná, potřebuje k ní programovací prostředek, jehož používání bude hned od počátku pociťovat jako výhodné a usnadňující práci. V opačném případě mu bude chybět motivace a programování zanechá.

- 8 -

Správná volba programovacího prostředku není pro příležitostného programátora jednoduchá. Jde o velmi specifické osobní rozhodnutí, které nelze kvalitně učinit bez dostatku relevantních informací.

Tato kniha chce všechny zájemce o vlastní programovou tvorbu upozornit na programovací jazyk PureBasic (1).

PureBasic je mimořádně snadno osvojitelný programovací nástroj s jednoduchou procedurální strukturou a bohatou multimediální výbavou.

Kód vytvářený jeho kompilátorem je velmi rychlý a umožňuje řešit i výpočetně náročné úlohy. Aplikace napsané v PureBasic jsou malé a snadno přenosné.

PureBasic umožňuje pracovat se stejným zdrojovým kódem pod čtyřmi různými operačními systémy (Windows, Linux, MacOS X a AmigaOS). V operačních systémech Windows mohou PureBasic aplikace vznikat jak v běžném 32-bitovém prostředí, tak v prostředí plně využívajícím vlastnosti 64-bitového procesoru (Windows XP Professional x64 Edition, Windows Vista 64-bit).

Převažujícím pocitem u všech nových uživatelů PureBasic je překvapení nad tím jak snadno a rychle se s tímto jazykem dá pracovat.

Přes nesporné přednosti, které PureBasic má, je tento programovací prostředek v Česku skoro neznámý.

Následující text proto není koncipován jako klasická učebnice popisující pouze syntaxi a paradigma programovacího jazyku, ale jako širší informativní studie přinášející čtenáři podklady k individuálnímu rozhodnutí o používání PureBasic v jeho vlastní praxi.

V textu jsou probírány základní vlastnosti jazyku PureBasic a mož-nosti, které nabízí pro příležitostnou tvorbu technických nebo ekonomických aplikací.

Všechny příkladové ukázky jsou bohatě komentovány. K jejich pochopení je postačující znalost normové minimální verze jazyku BASIC (2).

Ve výkladu jsou záměrně vynechány speciální příkazy a funkce určené pro programování počítačových her. Vážné zájemce o tuto problematiku odkazuji na informace uvedené v PureBasic dokumentaci.

- 9 -

Luboš Svoboda

- 10 -

1. Historie PureBasic

Příležitostné programování (casual programming) se objevilo v oka-mžiku ve kterém časové sdílení (time sharing) umožnilo k počítači současně přistupovat většímu počtu uživatelů.

Prostřednictvím koncových terminálů mohli začít sálové počítače využívat i pracovníci, kteří neměli programování jako hlavní pracovní náplň.

S cílem usnadnit těmto pracovníkům tvorbu programového kódu byl na Darmouth College v roce 1964 vytvořen jazyk BASIC (3).

Podstatným rysem jazyku BASIC byla možnost snadné interaktivní práce s centrálním počítačem, číslování řádků zdrojového kódu

a pečlivě vybraný soubor příkazů s jednoduchou syntaxí založenou na používání běžných anglických slov.

Další velký nárůst  používání zaznamenal BASIC po nástupu stolních osmibitových počítačů. Tyto „osmibity“ zprvu sloužily jako profesionální počítače , ale s dalším rozvojem mikroprocesorů a zlevněním jejich výroby začaly vytvářet segment počítačů domácích.

K  rozšíření a oblibě jazyku ve své době jistě přispěl fakt, že na mnohých mikropočítačích byl BASIC často jediným zdarma dodávanýmjazykem. Někdy tvořil součást operačního systému uloženého v ROM a v případě domácích počítačů dokonce i operační sytém fakticky nahrazoval.

Hlavní příčinou dlouhodobého úspěchu jazyku BASIC (který patří k nejpoužívanějším programovacím prostředkům už páté desetiletí) je však zřejmě postupný vývoj jeho jazykového paradigmatu a s tím související vznik mnoha různých BASIC dialektů.

Seznam BASIC dialektů ve Wikipedii má asi 450 položek a zdaleka nejde o seznam vyčerpávající.

Starší interpretační varianty jazyku BASIC (Basica, GW Basic) realizovaly prosté imperativní paradigma, založené na jedné hlavní příkazové sekvenci (určené čísly programových řádků) s občasnými podmíněnými odskoky a

- 11 -

skoky. Takový program je snadno zobrazitelný pomocí vývojového diagramu. Jednoduchá příkazová sekvence (označovaná dnes také jako „naivní

paradigma“) umožňuje přehledně řešit jen jednoduché výpočetní úlohy jejichž kód není příliš dlouhý.

S nárůstem výkonosti počítačů a s nárůstem složitosti řešených problémů délka programového kódu zákonitě vzrůstala. Bylo stále obtížnější orientovat se v programech, které nebyly zřetelně rozdělen do nějakých menších a relativně samostatných částí.

K dělení BASIC programů do menších částí (strukturování) se nejprve začala intensivně využívala odskoková subroutina realizovaná pomocí příkazové dvojice Gosub – Return a tento způsob programování se označoval jako strukturně orientovaný (4). Později se přikročilo ke strukturování programů pomocí relativně samostatných specializovaných částí programu nazývaných procedury.

Zcela podstatné je, že procedury pracují s předem určeným souborem vstupních dat přičemž prvkům tohoto souboru jsou při volání procedury přiřazovány   různé hodnoty. Při zpracování těchto dat se zpravidla využívají lokálními proměnné, které jsou platné a zpracovatelné jen uvnitř procedury.

Potřeba racionálního zpracování  velikostně rostoucích zdrojových souborů nakonec vedla k prosazení procedurální orientace jazyku BASIC.

Procedurální paradigma se od prostého imperativního paradigmatu, liší intesivním využíváním přiřazovací příkazů, umožňujících provádění určité příkazové sekvence (procedury) na různých místech programu.

Existence procedury usnadňuje strukturování programového kódu a umožňuje budovat programy shora dolů (top-down design).

Nejprve se vytvoří kostra (celková struktura) programu tvořená propojením hrubě naznačených programových modulů a procedur.

Struktura programu připomíná kořenový systém. V dalších fázích se

pak detailní obsah jednotlivých kódových bloků postupně upřesňuje.Existence lokálních proměnných zároveň umožňuje i smysluplné

budování programů zdola nahoru (bottom-up design) z dříve detailně připravených procedurálních modulů.

Lidskému myšlení je koncept opakovaně aktivované procedury blízký a procedurálně orientované dialekty (Microsoft Quick Basic,

- 12 -

Borland TurboBASIC, PowerBASIC) se brzy staly mezi uživateli přechozích verzí BASIC velmi oblíbenými.

Opuštění konceptu číslovaných řádků usnadnilo používání celostránkových textových editorů k úpravě programu, což přineslo vyšší editační komfort a díky formátovacím možnostem zvýšilo přehlednost zdrojových textů.

Pokud se jednalo o o kompilované programovací prostředky, přinesly nové procedurální dialekty i podstatné zvýšení výpočtové rychlosti i přes to, že byly určeny pro o použití ve stejném  16bitovém prostředí DOS.

S nástupem Windows 95 bylo možné očekávat oslabení pozice všech programů pracujících v prostředí DOS. Na tuto skutečnost Microsoft reagoval vydáním VisualBasic 4.0 určeného jak pro 16bitové prostředí DOS, tak pro 32bitové prostředí Windows 95.

Pro podporu procedurálního modelu programování v 32bitovém prostředí nového operačního systému Microsoft vyvinul i univerzální aplikační rozhraní (Win32 API) poskytující aplikacím jednotný přístup k obecně použitelným službám a funkcím.

Vzhledem k obrovské komplexnosti aplikačního rozhraní se ukázalo jako nejvýhodnější formulovat   API  pomocí speciálních objektově orientovaných knihoven.

Tento fakt usnadnil (nebo možná i zapříčinil) postupnou penetraci objektového paradigmatu do dalších Windows verzí jazyku BASIC.

V případě jazyku VisualBasic došlo k definitivnímu posunu do oblasti objektově orientovaného programování přepracováním VisualBasic 6 na verzi označovanou jako VB.NET. Tato verze dnes převažuje a umožňuje profesionálům a poloprofesionálům VB.NET používat jako dobře dostupnou náhražku jazyku C#.

V základním provedení (VB.NET Express Edition) jde o bezplatný programovací prostředek, což vypadá lákavě. Potřebám příležitostných uživatelů se však VB tímto posunem vzdálil a méně příležitostní uživatelé často narazí na omezení, které základní provedení má.

Vzniklá situace byla pro „bejzikáře“ nepatřící k profesionálním programátorům dosti nepříznivá. Už samotné zvládnutí aplikačního rozhraní je dosti náročné a příklon k tvorbě objektově orientovaných programů představuje další komplikaci.

Pokračovat v práci s původním DOS jazykem je sice ještě stále možné, ale ani pro příležitostné programátory to není trvalé a perspektivní řešení. V DOS nejsou podporována „dlouhá jména“ souborů a problémy mohou přinést jména všech adresářů obsažených v cestě k příslušnému programu. Řadu potíží přináší nutnost používání rozdílné kódové stránky při práci s českou diakritikou. Možnosti spolupráce DOS programů

- 13 -

s Windows programy jsou omezené a ani obsluha USB periferií není bez problémů.

V novějších operačních systémech (Windows Vista, Windows 7) se problémy s používáním DOS/BASIC programů ještě prohloubily, protože tyto operační systémy nepodporují 16bitové aplikace. Programy napsané v DOS/BASIC je proto nutné provozovat prostřednictvím speciálního emulátoru

(DOSBox). Řada DOS/BASIC programů přesto zřejmě i v dnešní době dobře

slouží, ale zcela nové programy už prakticky nevznikají. Je zřejmé, že při přechodu z DOS/BASIC na Windows/BASIC

dialekt nemůže nikdy jít o jakýsi zcela jednoduchý „upgrade“. Grafické uživatelské rozhraní představuje zcela novou entitu jejíž obsluha zabírá podstatnou část z programového kódu.

Na trhu jsou sice kromě VB.NET i další nástupnické Windows verze původního jazyku BASIC, ale ani jejich tvůrci nedokázali (nebo nechtěli) upustit od využívání Windows API.

I když je použití Win API nejlogičtějším řešením, jeho monstrózní velikost odrazuje příležitostné programátory.

Jazyk, který je na Win API nezávislý v nabídce dlouho chyběl.. Takovým jazykem se stal až PureBasic, který je produkován a vyvíjen v ma-lé francouzské firmě Fantaisie Software.

Firmu Fantaisie Software vlastní Frederic Laboureur, který je autorem jazyku PureBasic a  při jeho dalším rozvoji působí ve firmě jako hlavní programátor (5).

PureBasic začínal jako nástroj usnadňující hobby programování v oblasti počítačových her. Původní verze z roku 1998 byla určena pro počítače Amiga, které byly používány především pro volnočasové aktivity a měly svůj vlastní operační systém. Relativní nezávislost PureBasic na Windows API tedy vlastně vyplynula z toho, že Windows nejsou pro PureBasic „mateřským“ OS.

První verze PureBasic pro operační systém Windows pochází z roku 2000.

Dodatečným benefitem nezávislosti na Windows API je relativně snadná portabilita do prostředí jiného operačního systému. Verze pro Linux se objevila o rok později a verze pro Mac OS X přibyla v roce 2005.

Verze pro počítače Amiga byla v roce 2006 převedena pod licenci open source a další firemní vývoj PureBasic pro platformu Amiga byl zastaven. Ostatní výše uvedené verze jsou nadále vyvíjeny paralelně.

- 14 -

Důležitý mezník v rozvoji PureBasic představuje květen 2006, kdy byl na trh uveden PureBasic 4.00.

Klíčovým přínosem verze 4.00 bylo zavedení dalších typů proměnných (zejména čísel s dvojnásobnou přesností), které podstatně rozšířilo možnosti PureBasic při  provádění vědecko-technických výpočtů.

PureBasic je koncipován jako klasický procedurální jazyk, který je vybavený vlastním souborem příkazů pro snadno osvojitelnou tvorbu grafického událostně řízeného rozhraní.  

Prakticky použitelné Win programy je možné začít psát velmi brzy po seznámení se základy PureBasic, protože k  jejich napsání není nezbytná

znalost Windows API (i když využívání Windows API je v PureBasic samozřejmě možné) . K převodu zdrojového kódu do podoby prakticky použitelné PureBasic aplikace zprvu sloužil dvoustupňový kompilátor, který nejprve převedl zdrojový PureBasic kód do kódu flat assembleru (FASM).

Další zpracování assemblerového mezikódu prováděl kompilátor pomocí open source překladače (6), který z flat assembleru vytvořil konečný soubor (*.exe) ve strojovém kódu.

Tento způsob zajišťoval (díky pečlivé „ruční“ optimalizaci assemblerrového mezikódu) náležitou rychlost PureBasic aplikací.

V současné verzi (PureBasic 5.00) jsou knihovny většinou napsány s použitím Visual C++ 2010.

Stále platí, že libovolnou část PureBasic programu je možné napsat také přímo v assembleru a bez problému vložit mezi ostatní řádky.

Nahrazování části PureBasic kódu pomocí ručně psaného assembleru však nebývá nutné. Aplikace vznikající po kompilaci zdrojového PureBasic kódu jsou i bez toho dostatečně  efektivní.

Typické aplikace vytvářené kompilátorem PureBasic mají podobu samostatně spustitelných exe souborů. Tyto soubory nepotřebují žádné zvláštní runtime prostředí a obvykle nepožadují ani žádné externí knihovny.

Výpočetní hbitost PureBasic aplikací lze ukázat na výsledcích získaných testovacím programem GAMMIX [Příklad I].

Program GAMMIX je tradiční benchmark složený z pěti cyklických algoritmů, ve kterých jsou opakovaně prováděny výpočetní operace typické pro vědecko-technické úlohy (7).

; Příklad I; Název souboru: GAMMIX.PB; středník slouží ke vkládání poznámek a komentářů

- 15 -

Dim A.f(100) ; pole typu floating pointDim B.f(30) ; pole typu floating point

Define.f X,S ; X a S jsou definovány jako proměnné typu floating point ; předem nedefinované proměnné jsou automaticky typu long

; vytvoření dvou polí celočíselných proměnných typu longFor I=1 To 100 A(I)=I Next I

For I=1 To 30 B(I)=I Next I

X.f = 0.12345PocetProvedeni = 100 Zacatek = ElapsedMilliseconds() ; počet milisekund od startu počítače

For K=1 To PocetProvedeni ; začátek opakovací smyčky

For I=1 To 1000 S=A(11) For J=1 To 10 L=11-J S=S*X+A(L) Next J Next I For I=1 To 33 S=0 For J=1 To 30 S=S+A(J)*B(J) Next J Next I For I=1 To 667 For J=1 To 30 B(J)=A(J)+B(J) Next J Next I For I=1 To 1333 S=X For J=1 To 5 S=(S-X/S)*0.5 Next J Next I

- 16 -

For I=1 To 67 S=A(1) For J=2 To 100 If A(J)>=S S=A(J) EndIf Next J Next I

;do opakovací smyčky je vloženo 5 smyček, které tvoří vlastní testNext K ; konec opakovací smyčky, která zajišťuje K provedení testu Trvalo = ElapsedMilliseconds()-Zacatek

; ladicí příkaz Debug zobrazí text, který za ním následuje; toto zobrazení je funkční pouze při spuštění programu v IDE; při kompilaci do exe souboru se Debug chová jako středník Debug "GAMMIX TEST BYL SPUŠTĚN V IDE !"Debug " "Debug "Spuštění zkompilovaného souboru přinese lepší výsledek. " Debug " "Trvalo$= Str(Trvalo) ; pro zobrazení se musí číslo převést na řetězec MessageRequester(Str(PocetProvedeni)+ "x Gammix test ", "Provedení trvalo: " + Trvalo$ + " ms") ; zobrazí informační okénko s výsledkem; okénko je automaticky opatřeno „zhasínacím“ tlačítkem OKEnd

Rychlost programů napsaných v PureBasic řádově překračuje rychlost dosahovanou staršími typy jazyku BASIC (Tab. 1). Spolu s vyšším výkonem soudobých počítačů to vede k nutnosti provádět původní GAMMIX test v mnohonásobné opakovací smyčce. Na počítači typu Pentium 4 (3 GHz, Win XP Pro) trvá stonásobné provedení testu pouze 31 ms.

Aplikace napsané v PureBasic nemusejí být instalovány. Pokud kromě exe souboru obsahují soubor helpu a pomocné datové soubory, zpravidla postačí umístit všechny soubory v jednom adresáři. S ohledem na uživatelské zvyky je samozřejmě možné šířit jakoukoliv PureBasic aplikaci ve formě instalačního balíčku a vyžadovat k instalaci administrátorská práva.

- 17 -

Exe soubory aplikací vytvořených v PureBasic mimořádně malé a portable aplikace jsou proto přenosné opravdu snadno.

Tabulka 1

Jazyk Relativní rychlost v testu GAMMIXMicrosoft GW Basic 1 Microsoft QBasic 0,9 Borlad TurboBasic 1,6Microsoft QuickBasic 4.5 5,1 Microsoft VisualBasic 6.0 12,1PowerBasic DOS 3.5 26,5 PowerBasic Console Compilator 4.0 31,3PowerBasic Win 8.0 31,3PureBasic 4.10 282,0

Univerzalita PureBasic je dána velkým množstvím modulárně

koncipovaných knihoven. Od verze 5.00 tyto knihovny obsahují více jak 1500 příkazů.

Algoritmizace problému se v PureBasic opírá o jednoduché a strukturované příkazové sekvence sestavované s pomocí procedur způsobem blízkým běžnému lidskému myšlení. V rámci jednoduchého procedurálního paradigmatu pracuje i událostně řízené rozhraní. Díky tomu je PureBasic mimořádně snadno osvojitelným pracovním nástrojem.

Zatímco začínající uživatelé využijí především základní knihovny PureBasic, pokročilí uživatelé ocení speciální knihovny určené pro nejrůznější aplikační oblasti.

Všechny příkazové knihovny mají společný adresář a jsou v zásadě rovnocenné, ale v integrovaném helpu jsou rozděleny do několika sekcí.

Do hlavní sekce (General Libraries) jsou společně zařazeny knihovny zajišťující vnější podobu PureBasic aplikací a knihovny používané při vlastním zpracování dat.

Do dvou dalších sekcí (2D Games & Multimedia Libraries a 3D Games & Multimedia Libraries) jsou vyčleněny herní knihovny, které mají pro vývoj vědecko-technických aplikací jen okrajový význam, ale kromě vývoje her se uplatňují i při vývoji aplikací výukových.

Multiplatformní charakter je považován za podstatný rys PureBasic a proto se uvažuje o rozšíření portability PureBasic i na další operační

- 18 -

systémy (OpenBSD). Pokud k tomu dojde, mají být i nové verze dostupné v rámci stávající doživotní user-based licence.

Pro toho kdo nemá profesionální programátorské vzdělání a programování nemá jako hlavní pracovní náplň představuje PureBasic velmi dobrou a možná i vůbec nejlepší cestu k vlastní samostatné tvorbě programových aplikací v prostředí OS Windows.

Na podporu tohoto tvrzení lze uvést, že na webové stránce „The Basics´ page“, věnované srovnávání BASIC dialektů pro Windows a Linux, se v roce 2012 PureBasic umístil na prvním místě (42).

S pomocí PureBasic příkazů lze realizovat většinu operací používaných při  obsluze grafického uživatelského rozhraní a při spolupráci s operačním systémem tedy není třeba využívat služeb Win API.

Samozřejmě je výhodné, že příkazy Win API přesto mohou být přímou součástí programového kódu.

Podle publikovaných prohlášení (8,9) má být jednoduchá a uživatelsky přátelská struktura PureBasic zachována i v budoucnu.

V lednu 2013 byl pro vlastníky předcházejících verzí uvolněn PureBasic 5.1 beta a na vývoji jazyku se dále pracuje.

I když PureBasic umožňuje začlenit do kódu objektově orientované prvky, celková transformace v objektově orientovaný jazyk se neplánuje.

Rozvoj PureBasic bude spočívat především v dalším vývoji 64bitové varianty a v tvorbě dalších knihoven vycházejících vstříc specifickým uživatelským potřebám.

- 19 -

PureBasic by měl tedy i v budoucnu zůstat zajímavou alternativou pro každého kdo potřebuje mít k dispozici univerzální programovací nástroj a nechce, nebo nemůže, věnovat mnoho času rozsáhlému studiu programovacích prostředků.

- 20 -

2. Pořízení PureBasic

PureBasic je možné nalézt v nabídce specializovaných softwarových obchodů (Manaccom AU, Amazon UK). Před nákupem „krabicového vydání“ je však vhodné si ověřit, zda příslušný prodejce dodává opravdu poslední verzi. Dalším problémem při takovémto způsobu pořízení bývá

absence licence potřebné k provádění bezplatného upgrade.

Výhodnější je učinit objednávku PureBasic přímo u firmy Fantaisie Software (10).

Částka 79 Eur požadovaná za možnost stažení všech tří placených verzí PureBasic (verze pro Windows, Linux a MacOS) je velmi příznivá. Po jejím zaplacení poskytuje Fantaisie Software licenční klíč, který umožňuje download a současné užívání všech výše uvedených verzí.

Licenční politika Fantaisie Software je vskutku velkorysá. Uživatel může nainstalovat PureBasic na každý počítač se kterým pracuje (user-based licence) a současně má právo na doživotní bezplatný upgrade.

Před vlastním nákupem programu je možné seznámit se s hlavními vlastnostmi PureBasic prostřednictvím demoverze (11). Demoverze sice neobsahuje úplně všechny programové knihovny a délka zdrojového

souboru je při jejím používání omezena, ale k vytvo-ření představy o vlast-nostech jazyka určitě postačuje.

Zvídavější zájemci si také mohou volně stáhnout úplný manuál PureBasic (12). Verze z listopadu 2012 (PureBasic 5.00 for Windows) má 1147 stran.

Stejně jednoduše dostupná je i kopie on-line dokumentace (help) plné verze PureBasic pro Windows (13).

- 21 -

Kromě toho může každý, kdo se zajímá o PureBasic, získat další informace na anglickém internetovém fóru firmy Fantaisie Software (14).

Registrace ve fóru je bezplatná a bezprostředně po zaregistrování je možné do fóra zasílat příspěvky a vznášet zde dotazy.

Komunita registrovaných uživatelů fóra má několik tisíc stálých členů a je opravdu mimořádně přátelská.

Panuje zde atmosféra vzájemné sounáležitosti a dotazy nováčků (nebo i pouhých zájemců o PureBasic) jsou přijímány velmi vlídně.

I relativně složité problémy jsou účastníky fóra ochotně řešeny.

Fórum je monitorováno vývojovým týmem Fantasie Software, jehož členové pravidelně reagují na relevantní podněty účastníků.

Podobným způsobem je možné využívat i fórum provozované v němčině (15), popřípadě i fórum

francouzské (16). Mezi oficiálními informačními zdroji je třeba uvést také stránky

německé pobočky Fantaisie Software (17). K volně dostupným praktickým

pomůckám se v poslední době přiřadila i elektronická podoba knihy „PureBasic – A Begginer´s Guide To Computer Programming“, kterou napsal Gary Willoughby (26, 27).

Jako správce oficiálních stránek PureBasic působí přímo Frederic Laboureur, ale informačně velmi hodnotné jsou také další stránky

- 22 -

spravované a provozované ostatními členy vývojového týmu a řadovými členy uživatelské komunity.

Stránky které vytváří André Beer (18) obsahují sbírku utilit pro programátorskou práci, free knihovny DLL pro PureBasic, jazykový tutoriál a různé zprávy. Tyto stránky jsou dostupné v anglické a německé jazykové verzi.

Stránky, které spravuje Benny Sels (19) jsou věnovány

grafickému vývojovému prostředí Visual Designer (které je dodáváno jako součást instalace PureBasic).

Timo Harter na svých stránkách zveřejňuje různé programovací utility a komentované kódové segmenty (20).

Pozornost si zaslouží vzorové příklady na stránkách, které vytvořil Horst Schaefffer (21) a velmi

dobře propracované tutoriály lze nalézt na dalších stránkách (22, 23, 24, 25).

Samozřejmě, že u těchto stránek dochází ke změnám pokud jde o jejich umístění (URL) a že stránky, které jsou výsledkem činnosti řadových uživatelů („fanoušků“) PureBasic zanikají a místo nich vznikají stránky nové.

Rozhodně se tedy vyplácí čas od času prohledat net a hledat nové zdroje. Dobrou taktikou je také navštěvovat

- 23 -

stránky, jejichž URL mají u svých příspěvků uvedené účastníci PureBasic fóra.

- 24 -

3. Instalace PureBasic

Instalace PureBasic v prostředí Windows probíhá standardním způsobem.

Po po spuštění instalačního souboru se v adresáři Program Files (nebo v jiném určeném adresáři) vytvoří podadresář PureBasic, který obsahuje další podadresáře (Catalogs,

Compilers, Debugger, Examples, Languages, Library SDK, Pure Libraries, Residents, SubSystems, Update).

I když obvykle používaným logem Fantaisie Software je ozubené soukolí, má zástupce PureBasic na ploše Windows podobu velkého červeného písmena Z. Je to dobře viditelný symbol, jehož aktivací se spouští integrované vývojové prostředí ve kterém je možné psát, ladit i kompilovat PureBasic programy.

Integrované vývojové prostředí programu PureBasic je založeno na volně použitelném editoru Scintilla (28) se kterým se setkáváme i v řadě dalších programů.

Po spuštění IDE (Integrated Development Enviroment) se objeví typické modře olemované žlutavé okénko editoru PureBasic, které je v horní části opatřené dvouřádkovou nástrojovou lištou.

Práce s jednotlivými prvky nástrojové lišty je natolik jednoduchá a intuitivní, že se nejeví jako účelné jí nějak blíže popisovat.

- 25 -

Levé horní okénko slouží k zobrazení a k editaci textu zdrojového souboru, v dolním levém okénku zobrazují běhová a chybová hlášení.

Důležitou součástí IDE je rozsáhlý vestavěný HTML Help. Obsahuje popisy všech příkazů, výklad syntaktických pravidel, uvádí typy proměných a objasňuje používání procedur. Jsou zde informace o práci s DLL a spolupráci s Windows API.

Elektronická dokumentace dodávaná spolu s PureBasic je dostupná ve třech jazykových verzích. Oficiální anglický on-line Help má francouzský a německý ekvivalent a rovněž k plnému i ke zkrácenému anglickém PDF manuálu existují francouzské a německé alternativy.

PureBasic ve verzi 4.30 obsahuje 1167 vnitřních příkazů. Tyto jazykové prvky vytvářejí 69 knihoven, které jsou v Helpu formálně rozděleny do tří příkazových sekcí.

Obecně použitelné vnitřní příkazy jsou uloženy do sekce General Libraries, která obsahuje 44 knihoven: 2D Drawing, AudioCD, Cipher, Clipboard, Console, Database, Date, Desktop, DragDrop, File, FileSystem, Font, Ftp, Gadget, Help, Http, Image, ImagePlugin, Library, Linked List, Mail, Math, Memory, Menu, Misc, Movie, Network, OnError, Packer, Preference, Process, Printer, RegularExpression, Requester, Scintilla, SerialPort, Sort, StatusBar, String, SysTray, Thread, Toolbar, Window a XML.

- 26 -

Speciální příkazy používané při programování 2D her a při obsluze zvukových periferií jsou umistěné v sekci 2D Games & Multimedia Libraries do které přísluší 9 knihoven: Joystick, Keyboard, Module, Mouse, Palette, Sprite & Screen, Sprite3D, Sound a SoundPlugin.

V poslední příkazové sekci 3D Games Libraries se nachází 14 knihoven: Engine3D, Billboard, Camera, Entity, Gadget 3D, Light, Material, Mesh, Node, Particle, Sound 3D, Terrain a Texture, Window 3D.

Každé knihovně je v Helpu věnována samostatná kapitola, obsahující syntaxi a popis činnosti jednotlivých příkazů. Součástí popisu je většinou i demonstrační příklad. Tímto strukturováním se se celý příkazový balík stává přehlednějším a je snadnější i jeho další rozšiřování.

Do adresáře Sources je možné ručně doinstalovat externí nápovědy. Ty jsou pak přímo dostupné ze záložky Help. Takto lze vestavět například nápovědu pro assembler a nápovědu pro Windows API.

Nadstandardní součástí IDE je Visual Designer, který se používá pro přímý návrh vzhledové podoby jednotlivých aplikací.

Přesto, že Visual Designer je ve skutečnosti zcela samostatný program, je dodáván spolu s instalačním programem PureBasic bez jakéhokoliv příplatku.

- 27 -

Spouštěcí položka Visual Designer se skrývá pod tlačítkem Tools, ale je možné i přímé spuštění klávesovou kombinaci Alt+V.

Visual Designer umožňuje interaktivní rozvržení ovládacích a zobrazovacích prvků stavebnicovou metodou. Výběr a umístění jednotlivých prvků navrhované aplikace se provádí myší (technikou Drag and Drop) a s pomocí myši lze snadno měnit i jejich velikost.

Po spuštění Visual Designer se na obrazovce objeví seskupení čtyř okének (Visual Designer, New window, Properties, Objects viewer).

Levé dolní okno (Properties) slouží k celkové konfiguraci vytvářeného okna a k úpravě vlastností jeho grafických prvků. V pravém dolním okně (Objects viewer) se zobrazuje stromová struktura navrhovaných oken a prvků. Levé horní okno (Visual Designer) obsahuje dvě karty sloužící jako zásobník jednotlivých grafických prvků, pravé horní okno (New window) představuje vlastní navrhovanou plochu.

Při práci v prostředí Visual Designer vidíme výsledný vzhled vytvářené aplikační obrazovky a můžeme ho bezprostředně upravovat (What You See Is What You Get).

Podrobně je práce s tímto nástrojem popsána v samostatném návodu, přístupném po stisku Help v horní liště okénka Visual Designer.

Funkčně podobné, ale vzhledově trochu odlišné je grafické návrhové prostředí PureFORM, které je dostupné jako freeware ( 29).

Komerční alternativou výše uvedených grafických návrhových prostředí je program PureVision (30) firmy Reel Media Production.

Další původně komerční řešení nabízí jako freeware pod názvem PBDev Developer firma HelloBasic (31).

- 28 -

Používání některého z uvedených grafi-ckých návrhových prostředí je otázkou osobních preferencí..

Zcela uspokoj-jivého vzhledu apli-kací lze dosáhnout i přímým napsáním pro-gramového kódu. Ani v tomto případě ne-trvá vytvoření apli-kačních obrazovek příliš dlouho.

Zdrojový kód PureBasic má formát prostého textu. K psaní programového kódu lze tedy použít kterýkoliv kancelářský textový editor, který má schopnost ukládat vytvořený soubor jako prostý text (např. MS Word, WordPad, Notepad).

V populárním freeware Crimson Editor (32) je možné nastavit barevné zvýrazňování jednotlivých jazykových prvků v souladu se syntaxí PureBasic.

Originální editor obsažený v IDE PureBasic je však kvalitní a protože každý registrovaný uživatel může mít PureBasic nainstalovaný na všech svých počítačích, není zpravidla důvod k jeho nahrazování nějakým kancelářským editorem.

K  výhodám originálního editoru patří automatické zvýrazňování rezervovaných slov (doplněné o průběžnou nápovědu správné syntaxe zobrazovanou v dolním řádku IDE) a snadná tvorba záložek. Editor má kontextuálně citlivý help a umožňuje bezprostřední přístup ke kompilátoru a debuggeru. Zdrojový kód v textu obsažených procedur je možné po libosti „sbalovat a rozbalovat“.

Textové segmenty programu je do editačního okénka IDE možné bez problému kopírovat pomocí schránky Windows či přenášet metodou drag and drop (např. z programu Microsoft Word).

Jediným nutným editačním zásahem při takovémto kopírování je případná úprava „českých“ párových uvozovek („ “), protože  PureBasic používá uvozovky jednodruhové (˝ ˝).

Volně dostupnou plnohodnotnou alternativou k originálnímu editoru je (funkčně trochu bohatší, ale také trochu komplikovanější) editor jaPBe vyvinutý pro PureBasic jedním z německých uživatelů (33).

- 29 -

Alternativní editor jaPBe a alternativní grafické uživatelské prostředí PureFORM jsou považovány za natolik významné, že mají v užitelském fóru PureBasic svou vlastní (společnou) rubriku.

- 30 -

4. Struktura a základní syntaxe

Z hlediska struktury a základní syntaxe je PureBasic jazykem respektujícím normu jazyku BASIC rozšířeným zejména o příkazy zajišťující zobrazení, tisk a komunikaci se soubory v podobě obvyklé v API Windows.

Jednoduchý komentovaný program napsaný v PureBasic je na základě znalosti normové podoby jazyku BASIC dobře srozumitelný [Příklad I].

V souladu s normou BASIC slouží jeden řádek zdrojového kódu jako prostor pro zapsání jednoho příkazu (včetně jeho operandů či parametrů). Pokud je na řádku více příkazů, musí být odděleny dvojtečkou.

V standardním integrovaném editoru PureBasic jsou u řádků automaticky zobrazována světle šedivá čísla, Tato čísla nejsou součástí kódu a vlastní průběh programu nijak neovlivňují. Slouží výhradně k lepší orientaci v textu zdrojového kódu při ladění programu v IDE.

Rozepisování jednoho programového řádku do více fyzických řádků (spojených do programového řádku pomocí nějakého spojovacího symbolu) se v PureBasic neprovádí.

Maximální délka programového řádku v IDE činí více jak 32 000 znaků, což vysoce překračuje běžně potřebnou délku řádku. Prakticky používané programové řádky obsahují většinou méně než sto znaků.

- 31 -

Při psaní programu v PureBasic jsou používány jazykové prvky typické pro normový BASIC. Jsou to především aritmetické a logické operátory, čísla, klíčová slova a vyhrazené názvy používané pro jednotlivé příkazy a standardní procedury.

Nezbytnou součástí kódu jsou také uživatelské názvy používané k označení jednotlivých proměnných, konstant a uživatelem definovaných příkazů a procedur.Pro starší procedurálních jazyky (např. TurboPascal 3.0, PowerBasic 3.5) byla typická práce v textovém (konzolovém) režimu. V případě úloh nevyžadujících žádné grafické operace měly programy napsané pro tento režim výhodu opravdu jednoduchého kódu nekomplikovaného žádnými grafickými „ozdobami“. Pro příležitostného programátora (zejména pokud má s prací v textovém režimu z dřívějška zkušenosti) proto může být lákavé, že v PureBasic lze konzolový režim jednoduše zapnout příkazem OpenConsole(). Takto aktivovaný konzolový mód je způsobem vkládání dat a způsobem zobrazování výsledků blízký jazyku GW Basic nebo QuickBasic. Pracuje s oknem podobným textové obrazovce někdejšího DOS. „Starobylý vzhled“ konzolového programu však dnes u některých uživatelů vyvolává určitou nedůvěru a neochotu k jeho používání.

Nelze pominout ani fakt, že s ohledem na určitou topornost příkazu pro interaktivní vkládání dat Input() je konzolová forma vhodná jen pro případy, kdy se do programu zadává nevelký počet údajů.

U menších programů (a zejména u programů určených pro vlastní potřebu) může úspora programátorské práce nad těmito nevýhodami převážit..

4.1 Aritmetické a logické operátory

Kromě operátoru pro celočíselné dělení obsahuje PureBasic v podstatě všechny operátory používané v normovém jazyku BASIC (Tab. 2).

Samostatný operátor pro celočíselné dělení v PureBasic implementován není. K dispozici je však operátor % poskytující zbytek vznikající při celočíselném dělení (modulo).

V tabulce také chybí operátor mocnění, protože v PureBasic se k výpočtu mocniny používá namísto tohoto operátoru standardní funkce Pow (Mocněnec, Mocnitel).

- 32 -

Tabulka 2

Priorita Symbol Význam

1 ( ) Levá a pravá závorka

2 ~ Binární NOT

3 >> Aritmetický posun doprava

3 << Aritmetický posun doleva

3 % Modulo (zbytek po celočíselném dělení)

3 ! Binární XOR

4 & Binární AND

4 | Binární OR

5 * Násobení

5 / Dělení

6 + Sčítání

6 - Odčítání

7 > Větší než

7 >= Větší nebo rovno

7 < Menší než

7 <= Menší nebo rovno

7 = Rovno (přiřazení nebo posouzení ekvivalence)

7 <> Nerovno

Priorita Symbol Význam8 And Logické AND (jeden i druhý)

8 Or Logické OR (jeden případně druhý)

8 Not Logické NOT (logická negace, logické invertování))

8 XOr Logické XOR (buďto jeden anebo druhý)

- 33 -

4.3 Psaní čísel

Pro zápis dekadických čísel se používají číslice 0 – 9, které mohou být doplněny znaménkem. Hexadecimální čísla mohou navíc obsahovat znaky A – F.

Při zápisu necelých dekadických čísel se v PureBasic používá desetinná tečka. Zápis čísel menších než jedna bez zápisu nuly před desetinnou tečkou povolen není.

Speciální význam mají některé znaky při použití na počátku čísla (před první číslicí). Počáteční $ je vyhrazeno pro hexadecimální čísla, počáteční znak % se používá pro čísla binární.

4.4 Klíčová slova

Klíčová slova podle normy BASIC, která jsou součástí  PureBasic mají statut vyhrazených slov a nemohou být používána jako uživatelské názvy.

Takovými slovy jsou například smyčkové dvojice (For – Next, Repeat – Until, While – Wend), podprogramový odskok (Gosub - Return), jednoduché podminečné větvení (If – Else – EndIf ), vícenásobné větvení (Select – Case – EndSelect), příkazy pro práci s daty (Data – Restore – Read), nepodmíněný skok (Goto), prohození proměnných (Swap) a ukončení programu (End).

Statut vyhrazených slov ale nemá samotné PRINT nebo INPUT, protože tyto tato slova jsou v PureBasic používány v podobě příkazů Print() a Input().

Vyhrazená slova jsou při zapsání v editoru PureBasic editorem okamžitě označena změnou barvy. Pokud jsou součástí vyhrazeného slova závorky, dochází k vyhrazení (a ke změně barvy) zapisovaného slova již při napsaní levé závorky.

4.5 Uživatelské názvy

Jednotlivé proměnné, návěští, konstanty, ukazatele nebo uživatelem vytvořené procedury se v PureBasic rozlišují  pomocí názvů (jmen)

- 34 -

zvolených uživatelem. Přípustný název musí být založen na znakové posloupnosti povolené normou BASIC.

Povolenou znakovou posloupnost mohou tvořit velká i malá písmena anglické abecedy (ASCII 65 – 90 a ASCII 97 – 122) , podtržítko (ASCII 95) a dekadické číslice (ASCII 48 – 57). Jednotlivé znaky se mohou libovolně kombinovat a opakovat, ale na první pozici povolené znakové posloupnosti nesmí být číslice.

Minimální délka povolené znakové posloupnosti je jeden znak. Na omezení maximální délky znakové posloupnosti se při praktickém používání PureBasic nenarazí (jediné omezení představuje maximální délka řádky v IDE do které se musí příkaz obsahující název proměnné vejít).

Při posuzování shody dvou posloupností se nerozlišují velká a malá písmena. Názvy MensiHodnota, mensihodnota a mensiHODNOTA označují tedy tutéž proměnnou.

Jako název jednoduché proměnné se v PureBasic používá přímo libovolná povolená znaková posloupnost, která však nesmí být totožná s posloupností tvořící některé vyhrazené slovo. Použití proměnné gOTO není možné, protože Goto je vyhrazené slovo.

Názvy návěští se tvoří stejně jako názvy jednoduchých proměných. Samotné návěští musí být na samostatném řádku a příslušná znaková posloupnost je na tomto řádku doplněna zakončující dvojtečkou. Dvojtečka však není součástí názvu návěští a v příkazech ke skoku na návěští se píše název návěští bez dvojtečky.

PureBasic dovoluje použít současně stejnou znakovou posloupnost pro návěští i pro proměnnou [Příklad II].

Pro konstanty se používají názvy tvořené povolenou znakovou posloupností před kterou se přidává uvozující znak #. Vyhrazeným slovem je konstanta #PI do které kompilátor PureBasic ukládá aproximovanou hodnotu Ludolfova čísla (3.1415926535897931).

Uvozující znak * je vyhrazen pro ukazatele (pointery). Zvláštní význam má název obsahující jako uvozující znak @. Udává adresu proměnné jejíž název je k symbolu @ připojen.

Uvozující znaky # a * jsou součástí jména. Jména RuznyNazev, #RuznyNazev a *RuznyNazev jsou tři různá jména.

K názvu proměnné může být připojena extense, která začíná tečkou a deklaruje typ proměnné (viz tabulka 3).

Bez explicitní typové deklarace jsou číselné proměnné v PureBasic typu Long. Tento typ se nastaví automaticky při prvním použití nedeklarované proměnné.

- 35 -

; Příklad II (PB 4.30); Název souboru: STEJNESLOVO.PB;1. ukázka funkčního, ale zřejmě zbytečně nepřehledného kóduStejneSlovo=0StejneSlovo:Debug StejneSlovoStejneSlovo =1 + StejneSlovoIf StejneSlovo < 3Goto StejneSlovoEndIfEnd

Při provádění vědeckotechnických výpočtů je často vhodné umístit na počátku programu řádek s příkazem Define.d (bez jakéhokoliv dalšího textu). Tím se nastaví u všech číselných proměnných typ Double.

Tabulka 3

Jméno Extense Spotřeba paměti Použitelný rozsahByte .b 1 byte -128 až +127Character .c 1 byte (ascii) 0 až +255Character .c 2 bytes (unicode) 0 až +65535Word .w 2 bytes -32768 až +32767Long .l 4 bytes -2147483648

až+2147483647

Float .f 4 bytes ±1.175494.10-38

až±3.402823.1038

Quad .q 8 bytes -9223372036854775808až +9223372036854775807

Double .d 8 bytes ±2.2250738585072013.10-308

až ±1.7976931348623157.10308

String .s Délka řetězce + 1 neomezenFixed String .s{Délka} Délka řetězce neomezen

Pomocí příkazu Define a příslušného názvu proměné je možné deklarovat typ každé proměnné zvlášť. Tato Individuální deklarace je

- 36 -

rovnocenná s přímým přidáním typové extense na konec názvu proměnné při prvním použití.

V případě textových proměnných (řetězců) dochází ke specifikaci typu také použitím názvu jehož posledním znakem je $.

Koncové $ je chápáno jako znak, který se podílí na tvorbě jména, takže Retezec a Retezec$ jsou dvě různé proměnné.

Zatímco Retezec$ je jednoznačně řetězcová proměnná, Retezec může být definován jako jakákoliv proměnná.

Aby nedocházelo při psaní programu ke zbytečným záměnám, je žádoucí používat $ v názvech řetězců buď důsledně ve všech případech, nebo nepoužívat vůbec [Příklad III].

; Příklad III (PB 4.30); Název souboru: RETEZEC.PB; 2. ukázka funkčního, ale zbytečně nepřehledného kódu

Define Retezec.sRetezec="Prvni retezec"Retezec$="Druhy retezec"Debug RetezecDebug Retezec$

Názvy indexovaných proměnných používaných pro pojmenování prvků polí se tvoří z povolené znakové posloupnusti ke které se přidávají kulaté závorky obsahující index nebo indexy specifikující konkrétní prvek pole. Celkový počet indexů může být až 255.

Zvláštní způsob deklarování konstant umožňuje příkazová dvojice Enumeration. – EndEnumeration.

Konstanty, jejichž názvy jsou samostatně umístěny na řádcích mezi těmito příkazy, tvoří seznam ve kterém každá jednotlivá konstanta získává unikátní celočíselnou hodnotu, která se mezi jednotlivými řádky liší o konstantní krok (standardní přírůstek hodnoty je +1).

To umožňuje používat tyto konstanty jako jednoznačně pojmenované identifikátory (nahrazující nic neříkající čísla souborů a příkazů).

- 37 -

4.7 Větvení a cykly

Příkazy napsané v PureBasic se po spuštění programu provádějí postupně jeden po druhém, tak jak za sebou následují v textu programu.

PureBasic nevyžaduje žádnou speciální deklaraci na počátku programu. Pokud je vyžadována nějaká deklarace (definice procedury nebo makra, dimensování pole, přepnutí do konzolového módu) postačuje její umístění kdekoliv před prvním použitím deklarovaného prvku.

Přirozenou postupnou příkazovou sekvenci je možné změnit jenom podmínkou (větvením), příkazem cyklu a příkazem skoku.

Tato skutečnost přispívá k dobré čitelnosti a snadné pochopitelnosti programů napsaných v PureBasic.

Větvení programu se nejběžněji vytváří s pomocí klíčových slov If – (Else) – (ElseIf) – EndIf.

Podmínka If je splněna pokud výraz následující bezprostředně za If je pravdivý, nebo má nenulovou hodnotu.

Klíčové slovo THEN se v PureBasic nepoužívá! Při splnění podmínky If se provádí vše co následuje za výrazem vyjadřujícím podmínku až do prvního Else, ElseIf, nebo do EndIf. Výraz vyjadřující podmínku musí být na samostatném řádku, nebo musí být od následujících příkazů oddělen dvojtečkou.

Použití Else a ElseIf je nepovinné. Jednoduchou podmínku tvoří tedy příkazová dvojice If – EndIf.

Větší programové úseky se dají vypustit či zařadit s pomocí příkazů CompilerIf - CompilerElse – CompilerEndIf.

Nepodmíněný cyklus s předem určeným počtem opakování se realizuje pomocí vyhrazené dvojice For – Next. Řídící proměnná této smyčky musí být celočíselná a nesmí být typu quad. Druh řídící proměnné kompilátor kontroluje.

Zvláštní typ cyklu se uskutečňuje s pomocí dvojice ForEach – Next, která způsobí postupné provádění cyklu se všemi prvky číslovaného seznamu specifikovaného v příkazu LinkedList().

K podmíněnému provádění cyklu (tedy k vícenásobnému opakování části programu) se s výhodou dají použít příkazové dvojice Repeat - Until (test na konci cyklu) a While – Wend (test na začátku cyklu).

- 38 -

Ve všech výše uvedených cyklech je možné použít příkaz Continue, jehož zavolání způsobí, že se právě prováděný krok nedokončí a cyklus pokračuje dalším krokem.

Mimořádné zkrácení kteréhokoliv cyklu je možné pomocí příkazu Break. Jeho provedením se cyklus okamžitě ukončuje a program pokračuje bezprostředně za koncem cyklu.

S pomocí skokového příkazu Goto lze další chod programu přenést do místa libovolného návěští.

Nepodmíněné Goto může poskytnout užitečné služby při ladění programu, v korektně odladěném programu k jeho použití není žádný

rozumný důvod.Zásadně zavrhovat  používání podmíněného

Goto není nutné, ale je žádoucí používat tento příkaz šetrně a jeho použití důsledně komentovat. Při neopatrném používání Goto může i v PureBasic snadno vzniknout nepřehledný „špagetový“ kód.

Zvláštním druhem skokového příkazu je odskok prováděný pomocí příkazové dvojice Gosub - Return. Tento typ skoku se používá

nejčastěji k opakovanému provádí určitého segmentu kódu, který se vyvolává z různých míst programu.

V normovém jazyku BASIC je možné tento odskok korektně ukončit pouze prostřednictvím závěrečného Return po kterém se zpracování programu vrátí na první příkaz následující za příkazem Gosub.

V PureBasic je navíc možné předčasné ukončení odskoku s pomocí speciálního příkazu FakeReturn za kterým následuje Goto. Protože Goto může být směřováno v podstatě kamkoliv, je tímto způsobem možné přenést další chod programu i mimo standardní návratový bod příkazu Return.

Pomocí podmíněného příkazu skoku se dají snadno realizovat nejrůznější cykly. Vždy je však možné takový cyklus vytvořit též pomocí některé z příkazových dvojic For-Next, While-Wend a Repeat-Until. Používání těchto dvojic je třeba preferovat (poskytují přehlednější kód a jejich rychlost se od rychlosti cyklu s podmíněným skokem neliší).

4.8 Matematické funkce

Běžné číselné funkce jsou v PureBasic soustředněny v knihovně Math, která obsahuje:

- 39 -

goniometrické fukce Sin(x), Cos(x), Tan(x),inversní goniometrické funkce ASin(x), ACos(x), ATan(x),celočíselnou část čísel s pohyblivou desetinnou čárkou Int(x) a IntQ(x),přirozený logaritmus Log(x), dekadický logaritmus Log10(x),n-tou mocninu Pow(x,n), odmocninu Sqr(x),zaokrouhlovací funkce Round(x,1) a Round(x,0,absolutní hodnotu Abs(x).

S vyjímkou funkce IntQ(x), která poskytuje celé číslo typu Quad a funkce Int(x), která poskytuje číslo typu Long, jsou výsledkem všech ostatních funkcí příslušejících do knihovny Math čísla typu Double. I ldyá to v manuálu není explicitně uvedeno, je v PureBasic k dispozici i konstanta #PI, která vrací hodnotu 3.1415926535897931.

Funkce Random(x), která poskytuje pseunáhodnou celočíselnou hodnotu z uzavřeného intervalu <0, x> je v PureBasic zařazena do knihovny Misc. Tato funkce pracuje s čísly typu Long a maximální pokytovanou hodnotou je tedy 2 147 483 647. Inicializace generátoru náhodných čísel se provádí pseudonáhodně při každém spuštění programu, může však být trvale nastavena na určitý počáteční bod pomocí RandomSeed(y).

Ve verzi 4. 50 ( a výše) doznala matematická knihovna rozšíření o hyperbolické funkce.

4.9 Uživatelské procedury a funkce

Možnost vytvářet v programu relativně samostatné programové úseky (procedury), které lze podle potřeby spustit na různých místech programu, je jednou základních vlastností jazyku PureBasic.

Prvním řádkem programového úseku definujícího proceduru je hlavička procedury, která začíná slovem Procedure.

Za úvodním slovem Procedure může být v  hlavičce deklarován typ procedury a musí zde být uvedeno jméno procedury. Součástí jména procedury je povinně závorka. V povinné závorce se umisťuje případný seznam s parametrů procedury. Definici procedury ukončuje samostatný řádek obsahující slovo EndProcedure.

Samotná definice procedury ještě neznamená její skutečné použití. K provedení definované procedury dochází až tehdy, když program v rámci postupného zpracovávání příkazů narazí na její spouštěcí příkaz. Spouštěcí příkaz nemůže být použit před definicí procedury.

Spouštěcí příkaz procedury má podobu uživatelského jména identifikujícího proceduru.

- 40 -

V povinné závorce je uveden seznam parametrů předávaných proceduře při jejím spuštění. Jednotlivé parametry (argumenty) jsou proceduře předávány jako hodnota (ByVal).

Procedury standardně zpracovávají vlastní (lokální) proměnné s tím, že počáteční hodnota těchto proměných může být dána hodnotou vstupujícího parametru a jejich výsledná hodnota nijak neovlivňuje hodnotu stejnojmenných proměných v hlavním programu.

Některé z proměných však mohou mít status sdílených proměnných (předem deklarovaný pomocí Shared) a hodnotu získanou v proceduře pak do do hlavního programu přinášejí.

V proceduře není dovoleno používat příkazy Goto nebo Gosub a nesmí být umístěna definice jiné procedury. Procedura však může volat jinou procedury, nebo i sama sebe (rekurzivní volání).

V PureBasic není implementován samostatný příkaz DEF FN pro definici uživatelské funkce. Místo uživatelské funkce se používá procedura ve které se příslušný funkční výsledek určí hodnotou přiřazenou pomocí příkazu ProcedureReturn.

; Příklad IV (PB 4.30); Název souboru: FAKTORIAL.PB

; maximální hodnota n = 20; procedura vrací jedno číslo ( n!) - chová se tedy jako funkceProcedure.q Faktorial(n)Define.q ff=1n = Int(n)While i<ni=i+1f= f * iWendProcedureReturn fEndProcedure

;alternativní procedura pro výpočet faktoriálu; ukázka použití rekurze - procedura volá sama sebe Procedure.q RekurzFaktorial(n)Define.q rIf n>1r=RekurzFaktorial(n-1)*nElse r=1EndIf

- 41 -

ProcedureReturn rEndProcedure

; Smyčka pro ukázkové testování procedur; její předvedení vyžaduje spuštění příkladu v IDEFor k= 1 To 20Debug k

Debug Faktorial(k)Debug RekurzFaktorial(k)Next k

4.10 Makropříkazy

Makropříkazy v podobě používané v PureBasic představují velmi silný nástroj umožňující neobvyklé řešení programovacích problémů. Kromě vytváření nových příkazů lze totiž s pomocí makropříkazu modifikovat i funkci příkazů stávajících.

Použití makra k vytvoření nového příkazu lze ilustrovat příkladem řešícím mazání obsahu konzolové obrazovky [Příklad V].

Příkaz ClearConsole(), který maže veškeré zobrazení v okénku konzole je funkční pouze v módu grafické konzole. V obyčejném konzolovém módu analogický mazací příkaz chybí. Může být však snadno nahrazen příkazovou dvojicí CloseConsole() – OpenConsole(). Používání této příkazové dvojice se usnadní právě vytvořením vhodného makra.

; Příklad V (PB 4.30); Název souboru: CLS.PBI

Macro CLSIf OpenConsole()EndIf; umístění OpenConsole() do podmínky zabraňuje chybovému hlášení; při pokusu o otevření konzole v případě, že konzole je již otevřena; případná nemožnost provedení OpenConsole(); se vyhodnotí jako nesplnění podmínky (čímž je chyba ošetřena) ; konzole je nyní v každém případě otevřená

;a je možné jí zavřítCloseConsole()

; po zavření konzole se otevře nová „nepopsaná“ konzole

- 42 -

OpenConsole ()

EndMacro

Pomocí makra je možné v PureBasic zřídit i klíčové slovo Then, které se v jazyku PureBasic normálně nepoužívá.

; Příklad VI (PB 4.30); Název souboru: THENMAKRO.PB

; příkaz THEN je v PureBasic zamlčen; pokud někomu vysloveně chybí může si ho zřídit pomocí makra

Macro Then:EndMacro; ani pak však není možné vynechávat koncové EndIf

; Smyčka pro ukázkové testování makra; její předvedení vyžaduje spuštění příkladu v IDEFor i = 1 to 10Podminka = Random(1) ; argument funkce Random je typu longDebug PodminkaIf Podminka > 0 Then Debug "Podmínka splněna": EndifNext i

4.11 Práce s řetězci

PureBasic obsahuje všechny klasické řetězcové funkce zmiňované v normě BASIC.

Vcelku nepodstatným rozdílem oproti jazykové normě je skutečnost, že v PureBasic názvy řetězových funkcí nejsou zakončovány znakem $. V okamžiku kdy si na to uživatel zvykne je to spíše výhoda.

Před tiskem nebo zobrazením číselné hodnot se v PureBasic musí provést převod čísla na řetězec. S ohledem na číselné typy k tomu slouží čtyři příkazy: Str(), StrQ(), StrF() a StrD().

- 43 -

Při běžných výpočtech se jako nejuniverzálnější jeví StrD(), který však u čísel kratších než double doplňuje do zobrazovaného řetězce nuly. To sice k čitelnosti výsledku nepřispívá, koncové nuly za desetinnou tečkou je však možné snadno odstranit pomocnou procedurou [Příklad VII].

;Příklad VII;BEZNUL.PBI

Procedure.s BezNul(Cislo.d); odstraňuje koncové nuly za desetinnou tečkouUpravovany$=StrD(Cislo.d)If CountString (Upravovany$,".")=1 While Mid(Upravovany$,Len(Upravovany$),1)="0" Upravovany$=Left(Upravovany$,Len(Upravovany$)-1) WendEndIfIf Mid(Upravovany$,Len(Upravovany$),1)="." Upravovany$=Left(Upravovany$,Len(Upravovany$)-1)EndIfProcedureReturn Upravovany$EndProcedure

Většinou je lepší provést zároveň s odstraněním přebytečných nul i zaokrouhlení čísla na určitý počet platných míst [Příklad VIII].

; PříkladVIII; FIXF.PBI; procedura pro fixaci formátu číslaProcedure.s FixF(PocetMist,Cislo.d)Trimovany$=StrD(Cislo.d)VychoziDelka=Len(Trimovany$)Zaokrouhlit.d = Cislo.d *Pow(10,PocetMist)If Zaokrouhlit.d - Int(Zaokrouhlit.d)<0.5Zaokrouhleno.d = Round(Zaokrouhlit,0)/Pow(10,PocetMist)ElseZaokrouhleno.d = Round(Zaokrouhlit,1)/Pow(10,PocetMist)EndIfTrimovany$=StrD(Zaokrouhleno.d)MomentalniPocet =Len(Trimovany$) - FindString(Trimovany$,".",1)If MomentalniPocet > PocetMist

- 44 -

KonecnaDelka = VychoziDelka -(MomentalniPocet - PocetMist)ElseKonecnaDelka=VychoziDelkaEndIfTrimovany$=Left(Trimovany$,KonecnaDelka)If Right(Trimovany$,1) = "."Trimovany$=Left(Trimovany$,KonecnaDelka-1)EndIfProcedureReturn Trimovany$EndProcedure

Tabulka 4

Regulární výrazyZnakylibovolný znak (kromě \ n) . jeden ze znaků [  ]kromě těchto znaků [^   ]skupiny \ w|\ W|\ d|\ D|\ s|\ S podporujePOSIXové skupiny nepodporujeOpakovánílibovolný počet * *?alespoň jeden +  +?nanejvýš jeden ?  ??min až max {min,max}  {}?Pozicezačátek řetězce ^ konec řetězce $hranice slova \ bZávorky a paměťskupina se zapamatováním (  )skupina bez paměti (?:  )třetí zapamatovaný \ 3  $3

K podstatným výhodám PureBasic patří existence speciálni knihovny Regular Expression, která umožňuje v prostředí PureBasic pracovat s regulárními výrazy v podobě známé z  jazyku Perl (Tabulka 4).

- 45 -

Tato knihovna je extrémně užitečná pro programy sloužící k extrakci nebo konverzi dat.

Součástí knihovny je šikovný příkaz IsRegularExpression() s jehož pomocí se kontroluje správnost vytvořeného regulárního výrazu.

4.12 Speciální příkazy

Speciální příkazy PureBasic jsou tvořeny znakovou posloupnost vyhovující normě BASIC, která je zakončena dvojicí kulatých závorek ve které může být umístěn jeden či více parametrů (číselných či slovních). Formálně se tedy podobají indexovaným proměnným. Protože příkazy patří mezi vyhrazená slova nemůže dojít k jejich záměně s indexovanou proměnnou.

Znaková posloupnost (název příkazu) má nejčastěji podobu anglické fráze (tvořené několika slovy bez mezer), která charakterizuje činnost příkazu.

Pro lepší čitelnost začínají jednotlivá slova příkazu standardně velkým písmenem (Camel Notation), v IDE je však možné zapisovat příkazy písmeny libovolné velikosti.

V okamžiku kdy editor IDE příkaz rozpozná (po napsání slovní fráze a levé závorky) se zapsané slovo barevně změní a velikost písmen se upraví do standardní podoby. Zároveň se v dolní části editoru objeví nápověda obsahující soupis možných parametrů příkazu a jeho stručnou charakteristiku.

Osobitou skupinu příkazů PureBasic představují ovládací prvky obsahující v názvu slovo Gadget. Tyto „gadgets“ slouží především k interaktivnímu řízení chodu programu a plní podobnou funkci jako objektové ovládací prvky používané v objektově orientových programech.

Umístění ovládacího prvku se uvádí pomocí pravoúhlých souřadnic udávajících vzdálenosti mezi levým horním rohem okna a levým horním rohem prvku.

V závorce doprovázející příslušný prvek se postupně uvádějí následujjící číselné proměnné: IdentifikačníČísloPrvku, OdLevéhoRohuOknaDoprava, Od LevéhoRohuOknaDolů, ŠířkaPrvku a VýškaPrvku.

Zatímco objektově orientované tlačítko představuje na okolí nezávislý prvek (jehož aktivace představuje z hlediska programátora samostatnou událost), tlačítko v PureBasic musí být v rámci programového okna zařazeno do opakovací smyčky, která testuje jeho

- 46 -

případnou aktivaci. Tímto způsobem zůstává zachován přirozený sekvenční charakter jazyku.

Díky této koncepci se v PureBasic spojuje klasické procedurální paradigma algoritmu řešené úlohy s událostně řízeným (event-driven) paradigmatem programového rozhraní.

Samostatnou skupinu příkazů tvoří „dotazovače“ t. j. příkazy obsahující v názvu slovo Requester. Tyto příkazy pro komunikaci

s uživatelem otevírají vlastní samostatná okénka. Pomocí těchto okének zajišťují některé zá-kladní úkoly (jako je otevření souboru, výběr písma, výběr barvy) a podávají různá hlášení.

Zde je vhodné připomenout, že i při použití speciálních příkazů PureBasic namísto příkazů Win

API, se programy vytvořené v PureBasic chovají jako standardní Windows aplikace.

- 47 -

5. Rozhraní a I/O operace

Protože účelem každého výpočtového programu vůbec je poskytnutí datové informace, jsou zde na prvém místě uvedeny způsoby, kterými PureBasic sděluje svému okolí data ve formě čísel nebo textu.

Následuje popis způsobů vkládání a načítání dat včetně řízení chodu programu pomocí klávesnice, nebo myši.

Kapitolu uzavírají pasáže o grafické prezentaci výsledků, ladění programu a ošetřování chyb.

5.1 Textový výstup

Textový výstup může být směřován na obrazovku (do jednoho nebo více oken), do souboru (na datový nosič) nebo na tiskárnu. Čísla se na tyto periferie musí posílat ve formě textových řetězců.

5.1.1 Výstup na obrazovku

Při spuštění programu v integro-vaném vývojovém prostředí je možné k výpisu dat na obrazovku použít příkaz Debug.

V okamžiku kdy program na příkaz Debug narazí, zobrazí řetězec, který je za tímto příkazem uvedený. Pokud někde v programu následuje další příkaz Debug, zobrazí se k němu příslušející řetězec na dalším řádku. K zobrazování řetězců příkaz používá samo-statné okénko (Debug Output) jehož obsah lze snadno uložit nebo kopírovat.

Pokud je za příkazem Debug umístěn číselný údaj dochází (pouze pro pro účel následného zobrazení) automaticky ke konverzi tohoto číselného údaje na řetězec.

; Příklad IX; Název souboru: POZDRAV4.PBDebug "Ahoj světe !"

- 48 -

Příkaz Debug je určen především k ladění programů. Nejčastějí slouží k  zjištění aktuálních hodnot proměnných a k pomocným hlášením.

Debug nezobrazuje znaky Unicode, ale pouze znaky ASCII. Ve většině případů to nehraje žádnou roli (použití Unicode pro ladicí hlášení nebývá nutné).

Při kompilaci se řádek začínající Debug z programu automaticky vypouští (kompilací příkladu IX by proto vznikl zcela nečinný programový soubor). .

V prostředí IDE se dá příkaz Debug použít i k okamžitému vyčíslení matematických výrazů.

Kromě aritmetických operací při jejichž provádění Debug respektuje prioritu operátorů, provádí příkaz Debug i výpočet hodnot standardních funkcí a umí správně zohlednit i závorky.

;Příklad X;kolik celkem budou stát 3 následující položky po přičtení DPH 19 %Debug (1178 + 2435 +9113)*1.19

Jistou zvláštností (která souvisí s ladicím zaměřením příkazu) je fakt, že až do okamžiku ve kterém začne zpracovávat číslo obsahující desetinnou tečku (což může být i proměnná typu Float, nebo hodnota nějaké standardní funkce), provádí Debug všechny operace jako celočíselné [Příklad XI].

;Příklad XI;Název;celočíselná a desetinná aritmetika v příkazu DebugDebug (5/3); zobrazí se 1Debug(5.0/3);zobrazí se 1. 666666666666667

Debug 5/2 + Sin(0); zobrazí se 2.0Debug Sin(0) + 5/2; zobrazí se 2.5

- 49 -

Debug 5/2 + 5/2; zobrazí se 4Debug 5/2 + 5/2.0; zobrazí se 4.5Debug 5/2.0 + 5/2; zobrazí se 5.0

Při respektování specifických vlastností příkazu Debug je možné využívat tento příkaz k okamžitým jednoduchým výpočtům a to nejen při ladění programu. Je dokonce možné i psát malé programy, které budou k výstupu výsledků využívat příkaz Debug, podmínkou ovšem je jejich spouštění v IDE, bez předchozí kompilace do samostatného souboru.

Programy určené pro opakované použití se ovšem běžně používají v podobě samostatného zkompilovaného exe souboru, která zajišťuje maximální rychlost a spolehlivost provádění.

Pokud se u zkompilovaného programu spokojíme s čistě textovým výstupem (konzolí), lze pro výpis na obrazovku použít klasický zobrazovací příkaz Print(), nebo jeho variantu s odřádkováním PrintN(). K tomu je potřebné provést nejprve přepnutí do konzolového módu, což se provádí příkazem OpenConsole() [Příklad XII].

; Příklad XII; Název souboru: POZDRAV2.PBOpenConsole() ; povinný úvodní příkaz textového móduPrintN ("Ahoj svete !") ; PrintN tiskne na obrazovku a po tisku odřádkuje; ( samotný příkaz Print v PureBasic ponechává kurzor na konci řádku!); „odháčkovaným“ zápisem slova světe se obchází diakritický problém; ( textový mód použivá kódovou stránku 852 obvyklou v DOS) PrintN ("") ; samotné odřádkování ;( závorka nesmí být prázdná, ale řetězec v závorce prázdný být může)Print ("Stiskni Return !")Input (); tady naopak závorka musí být prázdná; Input() způsobí, že program čeká na vstup a zobrazuje text pozdravu; černé textové okénko by se jinak po vykonání příkazu tisku zavřelo

V konzolovém módu je pro zobrazování dat k dispozici textové černé okénko, které je vzhledově shodné s okénkem jednoduché DOS aplikace.

- 50 -

Tvorba kódu v konzolovém módu je velmi rychlá a jednoduchá. Díky tomu zůstává konzolový mód životaschopnou alternativou pro psaní textově orientovaných aplikací.

I když program spuštěný v konzolovém módu není pravou DOS aplikací, chováním se DOS programům v mnohém podobá.

K příjemným analogiím patří možnost redirekce výstupu. Do příkazové řádky spouštějící konzolový program se za název programu zapíše operátor > následovaný cílem redirekce (názvem souboru nebo zařízení) a tiskový výstup místo na obrazovku směřuje na specifikovaný cíl.

Za méně příjemnou analogii s DOS programy je naopak možné pokládat vzhled písma na obrazovce. Hůře vyhlížejí zejména znaky s diakritikou.

Skutečnost, že obrazovka konzolových programů zobrazuje znaky podle kódové stránky 852, je výhodou i nevýhodou. Pokud do IDE přenášíme kopie textu vytvořeného v DOS prostředí (například při úpravě staršího zdrojového kódu) je přenos velmi jednoduchý. Pokud ale píšeme program přímo v IDE (které pracuje s kódovou stránkou 1250), pak se některé české znaky nezobrazují správně.

V programech určených pro vlastní potřebu je možné neshodu kódových stránek uspokojivě obejít tím, že se zobrazované texty píší bez diakritiky.

Při psaní textově chudých aplikací se ojedinělé „problematické“ znaky vloží na příslušné místo v řetězci pomocí příkazu Chr().

U programů textově bohatších je lepší na počátek programu zařadit segment obsahující procedury Vymena() a a Prevod(), které jsou blíže specifikovány v dále uvedených příkladech.

Používání české diakritiky v konzolovém módu umožňují následující programy.

; Příklad XIII; Název souboru: PREVODNIK.PBI; obsahuje definici procedury Prevod zajišťující převod českých znaků; k převodu dojde v řetězci, který je argumentem při volání procedury; tento příklad je programový segment, proto má v názvu extensi PBIProcedure.s Vymena (StaryZnak$, NovyZnak$)Shared Vysledny$Vysledny$= ReplaceString(Vysledny$,StaryZnak$,NovyZnak$)ProcedureReturn Vysledny$EndProcedure

- 51 -

Procedure.s Prevod(Prevadeny$)Shared Vysledny$Vysledny$=Prevadeny$; voláním procedury výměna se postupně transformuje až 43 znaků Vymena("Ľ", Chr(149))Vymena("ľ", Chr(150))Vymena("ô", Chr(147))Vymena("ŕ", Chr(234))Vymena("ä", Chr(132))Vymena("ĺ", Chr(146))

Vymena("Ô", Chr(226))Vymena("Ĺ", Chr(145))Vymena("á", Chr(160))Vymena("č", Chr(159))Vymena("é", Chr(130))Vymena("í", Chr(161))

Vymena("š", Chr(231))Vymena("ú", Chr(163))Vymena("ů", Chr(133))Vymena("ž", Chr(167))Vymena("Á", Chr(181))Vymena("Č", Chr(172))

Vymena("Ť", Chr(155))Vymena("Ň", Chr(213))Vymena("Ď", Chr(210))Vymena("Ó", Chr(224))Vymena("É", Chr(144))Vymena("Ě", Chr(183))

Vymena("Í", Chr(214))Vymena("Ř", Chr(252))Vymena("Š", Chr(230))Vymena("Ú", Chr(233))Vymena("Ů", Chr(222))Vymena("Ž", Chr(166))

Vymena("Ý", Chr(237))Vymena("ě", Chr(216))Vymena("ť", Chr(156))Vymena("Ä", Chr(142))Vymena("ý", Chr(236))Vymena("ř", Chr(253))

Vymena("Ŕ", Chr(232))

- 52 -

Vymena(Chr(239), Chr(212)) ;ďVymena(Chr(243), Chr(162)) ;óVymena(Chr(242), Chr(229)) ;ňVymena(Chr(176), Chr(32))Vymena(Chr(10), Chr(32))

Vymena(Chr(13), Chr(32))

ProcedureReturn Vysledny$EndProcedure

; Příklad XIV; Název souboru: KONZOLTEXT.PB

OpenConsole()

IncludeFile "PREVODNIK.PBI" ; vsune na toto místo text příkladu XIII

Test$=("příliš žluťoučký kůň úpěl ďábelské ódy Ř Í Š Ž Ť Č Ý Ů Ň Ú Ě Ď Á É Ó")

Print ("Wrong: ")PrintN(Test$)PrintN(" ")Print("Right: ")PrintN(Prevod(Test$))PrintN(" ")PrintN(Prevod("Stiskněte ENTER !"))Input()

Při tisku do souboru prováděném pomocí WriteStringN() z konzolového prostředí se specifické české znaky napsané na konzoli při použití příkazu Input() musí rovněž transformovat. Použije se k tomu zcela analogická dvojice převodních procedur.

- 53 -

; Příklad XV; PREVODNIK2.PBI; napsáno pro PureBasic 4.20Procedure.s Vymena2(StaryZnak$, NovyZnak$)Shared Vysledny2$Vysledny2$= ReplaceString(Vysledny2$,StaryZnak$,NovyZnak$)ProcedureReturn Vysledny2$EndProcedure

Procedure.s Prevod2(Prevadeny2$)Shared Vysledny2$Vysledny2$=Prevadeny2$

; opakovaným voláním procedury Vymena2 se postupně transformuje text

Vymena2( Chr($B5), Chr(193)) ;ÁVymena2( Chr($AC), Chr(200)) ;Č

Vymena2( Chr($9B), Chr(141)) ;Ť

Vymena2( Chr($D2), Chr(207)) ;ĎVymena2( Chr($E0), Chr(211)) ;ÓVymena2( Chr($90), Chr(201)) ;ÉVymena2( Chr($B7), Chr(204)) ;ĚVymena2( Chr($D5), Chr(210)) ;Ň

Vymena2( Chr($E6), Chr(138)) ;ŠVymena2( Chr($E9), Chr(218)) ;ÚVymena2( Chr($DE), Chr(217)) ;ŮVymena2( Chr($A6), Chr(142)) ;Ž

Vymena2( Chr($ED), Chr(221)) ;ÝVymena2( Chr($D6), Chr(205)) ;Í

Vymena2(Chr(159), Chr(232)) ;čVymena2(Chr($82), Chr(233)) ;éVymena2("ˇ", Chr(237)) ;íVymena2(Chr(231), Chr(154)) ;šVymena2(Chr($A3), Chr(250)) ;úVymena2(Chr($85), Chr(249)) ;ůVymena2(Chr($A7), Chr(158)) ;ž

Vymena2(Chr(156), Chr(157)) ;ťVymena2(Chr($F8), Chr(245)) ;ý

Vymena2(Chr($D4),Chr(239)) ;ď

- 54 -

Vymena2(Chr($A2), Chr(243)) ;óVymena2(Chr($E5),Chr(242)) ;ňVymena2(Chr($FD),Chr($F8)) ;řVymena2(Chr($EC),Chr($FD)) ;ýVymena2(Chr($D8),Chr($EC)) ;ěVymena2(Chr($A0),Chr($E1)) ;áVymena2( Chr($FC), Chr(216)) ;Ř

Vymena2(Chr(10), Chr(32))

Vymena2(Chr(13), Chr(32))

ProcedureReturn Vysledny2$EndProcedure

K dosažení korektního textu se musí aplikovat procedura Prevod() na každý řetězec s diakritikou. To lze provést buď individuálně pro každý řetězec zvlášt, nebo je možné s pomocí makra převáděcí proceduru hromadně aplikovat na všehny řetězce tištěné příkazem PrintN().

I po všech úpravách zůstává slabinou konzolového módu celkový vzhled textově orientovaného rozhraní.

Současný standard pro vzhled a obsluhu aplikací dnes představují graficky orientovaná uživatelská rozhraní (Graphical User Interface). Tomu odpovídá i normální zobrazovací mód PureBasic, který je konformní s GUI Windows.

V PureBasic programem pracujících v normálním (Windows) módu lze „pozdravit svět“ více způsoby. Následující příklad [Příklad XVI] obsahuje (kromě nepovinných komentářů) jediný řádek s příkazem Windows API. Po kompilaci vytváří soubor o velikosti 2 KB.

; Příklad XVI; Název souboru: POZDRAV1.PB; středník slouží ke vkládání poznámek a komentářů ; může být v libovolném místě řádku; za středníkem může být cokoliv, nic co je za ním nebude čteno

MessageBox_(0,"Ahoj světe !","",0) ; toto je příkaz API Windows

; zobrazí pozdrav v okénku opatřeném dialogovým tlačítkem OK

- 55 -

Na místo příkazu API Windows je možné použít vlastní příkaz jazyku PureBasic s prakticky ekvivalentní funkcí[Příklad XVII]. Ten po kompilaci vytvoří soubor o velikosti 3 KB (tedy jen o něco málo větší než při přímém užití API).

; Příklad XVII; Název souboru: POZDRAV3.PBMessageRequester("", "Ahoj světe !") ; zobrazí okénko s pozdravem a dialogovým tlačítkem OK

Samostatné okénko příkazu MessageRequester() je určeno především k zobrazování krátkých hlášení. Pokud je MessageRequester() použit pro prezentaci delší informace je vhodné text strukturovat do více řádků. Jednotlivé řádky se

vytvoří z textových řetězců zakončených řídícím kódem Chr(13).Nápisy v běžném programovém okně se nejčastěji provádějí pomocí

příkazů TextGadget() a DrawText(). Tyto prostředky se používají především k nadpisům a poznámkám (tedy opět spíše pro kratší texty).

Popisy tlačítek se provádějí přímo ve struktuře příslušného příkazu ButtonGadget() vytvářejícího tlačítko. Rovněž příkaz Frame3DGadget(), používaný pro tvorbu rámečků, má svůj vlastní textový parametr.

Texty které se budou po zobrazení přepisovat se zobrazují pomocí StringGadget().

Zajímavou možností pro zobrazování rozsáhlejších textů je volání vhodného externího programu.

Potřebný text se zapíše do do dočasného nebo trvalého souboru a obsah souboru se následně zobrazí externím programem. Externí program se vyvolá příkazem RunProgram().

Volaným programem může s výhodou být Microsoft Notepad. Jeho přítomnost lze totiž předpokládat prakticky na každém počítači s operačním systémem Windows a bývá k němu i nastavena cesta.

Externí program zobrazí příslušná data ve svém vlastním okně a po jeho zavření (nebo po návratu do okna PureBasic) se pokračuje opět v práci s PureBasic aplikací.

- 56 -

5.1.2 Výstup do souboru

Při práci se soubory je pro PureBasic typický sekvenční zápis alfanumerických dat. Do zvoleného souboru se alfanumerická data zapisují jako jednotlivé znaky, jednotlivá čísla, nebo jako celé textové řádky.

Po vytvoření souboru příkazem CreateFile() do něj lze jenom psát. Jestliže je soubor navíc otevřen příkazem OpenFile(), je možné ze souboru také číst.

Při vytvoření nebo po otevření souboru je ukazatel určující místo budoucího zápisu (pointer) nastaven na počátek souboru.

Po otevření souboru, který už obsahuje data, by docházelo k přepsání začátku souboru novými daty. Tomu je třeba zabránit přesunutím ukazatele na konec souboru. Přesunutí se provádí s pomocí příkazu FileSeek(), do kterého se jako parametr vloží délka souboru [Příklad XVIII].

; Příklad XVIII; Název souboru: PRIPISRADEK.PBI

Procedure.s AppendString(JmenoSouboru$, Radek$) IdCislo.l = OpenFile(#PB_Any, JmenoSouboru$) ; zavolaná procedura otevře soubor; (pokud by neexistoval, tak ho vytvoří); souboru je přiděleno volné identifikační číslo; (nové volné číslo se přiděluje vždy po použití konstanty #PB_Any) ; pokud se otevření povedlo, je IdCislo nenulové

If IdCislo FileSeek(IdCislo, Lof(IdCislo)) ; přesune ukazatel na konec souboru ; (využívá k tomu délku souboru zjištěnou pomocí příkazu Lof) WriteStringN(IdCislo,Radek$) CloseFile(IdCislo) Else ;zde může být chybové ošetření ( soubor nešel otevřít - IdCislo=0) EndIfEndProcedure

Přesun ukazatele na konec souboru je třeba provést pouze bezprostředně po otevření souboru. V otevřeném souboru se ukazatel

- 57 -

zároveň s postupnými zápisy posouvá tak, že dochází k novému zápisu až za konec předcházejího zápisu. Opakované použití CreateFile() na již existujcí soubor vede k jeho nahrazení prázdným souborem.

Pokud je příkaz OpenFile() použit k otevření neexistujícího souboru, vytvoří se nejprve prázdný soubor a vytvořený prázdný soubor se zároveň také otevře.

Zapisovat je možné jednotlivé byte nebo jednotlivé proměnné. Nejčastěji se zápis do souboru řeší formou zápisu řetězcové proměnné s pomocí příkazu WriteStringN(), který provádí po zápisu i odřádkování.

5.1.3 Výstup na tiskárnu

Volba tiskárny v PureBasic se nijak neliší od volby tiskové služby v jiných programech. První tiskový příkaz způsobí rozsvícení okna ve kterém se zvolí příslušný tiskový prostředek ze stávající nabídky.

Provést dávkový tisk více souborů ve formátu .PDF není úplně lehký úkol. PureBasic umožňuje opakované volání programu Acrobat Reader a při každém novém voláním může být programu Acrobat Reader předložen k tisku jiný soubor. Sada souborů k tisku může být vytvořena mnoha způsoby. V ukázkovém příkladu [Příklad XIX] tvoří tištěnou sadu soubory s jednoduchými číslicovými názvy.

; Příklad XIX; Název souboru: TISKPDF.PB

; program uskutečňuje dávkový tisk PDF souborů pomocí opakovaného¨; volání programu Acrobat Reader

; v následující smyčce bude postupně přistoupeno k tisku 20 souborů; uložených v adresáři C:\k tisku; soubory jsou pojmenovány 1.PDF - 20.PDF; ve vlastním příkazu k tisku se využívá „nedokumentovaný“ přepínač; programu Acrobat Reader

Tisk.S = "hp LaserJet 1015" Acrobat.S = "C:\Program Files\Adobe\Acrobat 6.0 CE\Reader\AcroRd32"; řetězce jsou deklarovány pomocí extense S

For i =1 To 20numb$=Str(i)

- 58 -

PDFko.S = Chr(34)+ "C:\k tisku\"+numb$ +".PDF" + Chr(34); tištěný soubor musí bý zapsán tak, aby se za přepínačem /t objevil včetně ; uvozovek – proto je při tvorbě názvu použito dvakrát Chr(34)

Debug PDFko.S; když bude program spouštěn v IDE vypíše se název tištěného souboru

RunProgram(Acrobat.S,"/t " + PDFko.S + Tisk.S,"",#PB_Program_Hide)

; následují pětivteřinová pauza chrání volaný program AcrobatReader; před "zakousnutím" - potřebná velikost pauzy může záviset na hardware Delay (5000)Next i

5.2 Alfanumerický vstup

Vstup alfanumerických dat lze uskutečňovat z klávesnice, výběrem z obrazovky prostřednictvím myši, načtením ze souboru nebo z datového protokolu vytvářeného nějakou periferií.

5.2.1 Vstup z klávesnice

V konzolovém módu se vstup hodnot zadávaných z klávesnice nejsnáze realizuje pomocí klasického příkazu Input.

; Příklad XX; Název souboru: VSTUP1.PBOpenConsole() ; povinná inicializace textového móduPrintN ("Napiste cislo a stisknete Enter ! ")TextovaPromenna$= Input() ; příkazem Input lze vkládat pouze řetězcePrintN ("Bylo vlozeno: "+TextovaPromenna$) ; tisknout lze též jen řetězcePrintN (""); pokud řetězec reprezentuje číslo, musí se před výpočtem provést konverzeCiselnaHodnota.f = ValF(TextovaPromenna$) ; číslo typu float pointCislo$ = StrF(CiselnaHodnota.f * 2)

- 59 -

CiselnaHodnota2.d = ValD(TextovaPromenna$) ; číslo typu double precisionCislo2$ = StrD(CiselnaHodnota2.d * 2) ; pokud by textová proměnná sloužila ke vstupu celého čísla,; bylo by vhodnějí použít příkazy Val a Str; (na rozdíl od ValD, ValF, StrD a StrF pracují jen s celými čísly)PrintN ("Při pouziti cisel typu float vyjde dvojnasobek vlozene hodnoty: "+Cislo$)PrintN ("Presnejsi dvojnasobek davaji cisla typu double: "+Cislo2$)PrintN ("")print ("Stisknete ENTER !")Input ()

Díky příkazům Print() a Input() je struktura konzolových programů velmi podobná struktuře programů v některém DOS dialektu BASIC. Starší DOS programy lze proto předělat na konzolové programy relativně snadno.

Příklad XXI představuje ukázku programu, který byl převeden do PureBasic minimální úpravou původní DOS verze.

; Příklad XXI; Název souboru: VELIKONOCE.PB; algoritmus určující velikonoční pondělí ve zvoleném roce a jeho okolí

OpenConsole() ConsoleTitle ("Velikonoce 1583 - 9999 n. l.")EnableGraphicalConsole(1) ; zapni „grafický“ konzolový mód ( mód 1)

START:; následujicí 3 příkazy fungují pouze v „grafickém“ konzolovém móduConsoleCursor(10) ; z blikajícího podtržítka udělá blikající čtverečekClearConsole()ConsoleLocate(1,1)

PrintN("Rok ?")Print(" (Enter = letos) ")Y$=Input()If Y$ = "" Y$= FormatDate("%yyyy", Date()) ; šablona %yyyy extrahuje z dnešního datumu letošní rokEndIf; algoritmus je platný pro gregoriánský kalendář a čtyřmístný rokY = Val(Y$)If Y<1583 Or Y>9999 Goto START

- 60 -

EndIf

ZvolenyRok=YPredtim= YPotom=Y; určuje se možný rozsah okolí zvoleného roku (max. ± 10 let) PrvaCastOkoli=0While Predtim > 1583 And PrvaCastOkoli<10 Predtim=Predtim - 1 PrvaCastOkoli=PrvaCastOkoli + 1WendDruhaCastOkoli=0While Potom<9999 And DruhaCastOkoli<10 Potom=Potom + 1 DruhaCastOkoli=DruhaCastOkoli + 1Wend

ClearConsole()PrintN(" ")

For Y=Predtim To Potom

; výpočetní jádro programu; původně publikováno jako program pro pro 8bit počítač; Jakub Tatarkiewicz: Problemy (PL) 11/1986 s.56

A = Y - Int(Y / 19) * 19 B = Y - Int(Y / 4) * 4 C = Y - Int(Y / 7) * 7 T = Int(Y / 100) P = 4 + T - Int(T / 4) M = P - Int(P / 7) * 7 P = 15 + T - Int(T / 4) - Int((8 * T + 13) / 25) P = P - Int(P / 30) * 30 P = 19 * A + P D = P - Int(P / 30) * 30

; barevné zvýraznění výstupu If Y<ZvolenyRok Color=12 ; světle červená Else Color=10 ; světle zelená EndIf If Y=ZvolenyRok Color=14 ; světle žlutá EndIf

- 61 -

ConsoleColor(Color, 0) Print (" " + Str(Y) + ": ") If D < 28 : Goto DVA : EndIf If D = 29 : Goto JEDEN : EndIf If A < = 10 : Goto DVA : EndIf

JEDEN: D = D - 1 DVA: P = 2 * B + 4 * C - D + M P = P - Int(P / 7) * 7 D = D + P If D > 8 : Goto DUBEN : EndIf D = D + 22

If D<9 Print (" ") ; slouží k zarovnání sloupce zobrazovaných dat EndIf PrintN (Str( D + 1) + ". b" + Chr(253) + "ezna") ; zobrazení ř ve slově března je zajištěno tiskem znaku s ASCII kódem 253

Continue ; tento příkaz působí jako by v tomto místě bylo Next Y; pokračuje s další možnou hodnotou Y od začátku smyčky; při vyčerpání přípustných hodnot řídící proměnné smyčku ukončí

DUBEN: D = D - 9 If D<9 Print (" ") ; zde slouží k zarovnání sloupce dat EndIf

PrintN (Str(D + 1)+ ". dubna")

Next Y

ConsoleColor(7, 0) ; šedivé písmo ( default color = 7)PrintN(" ")PrintN (" Znovu ?")Print (" (a= Ano n = Ne) ")ANONE:I$ = Inkey()If I$ = "a" Or I$ = "A" Goto STARTEndIfIf I$ = "n" Or I$ = "N" End ; konec programuEndIf

- 62 -

Goto ANONE

V konzolovém módu se ke vstupu jednoznakové alfanumerické proměnné dá použít také příkaz Inkey(), který provádí „odchycení“ stisknuté klávesy. Časté je používání Inkey() k dočasnému zastavení programu (čekání na stisk klávesy), nebo k dotazu na další postup programu.

V PureBasic je implementován i šikovný příkaz RawInkey(), který znak stisknuté klávesy interpretuje dekadickým číslem ASCII kódu.

Pomocí RawInkey() se snadno vyhodnucuje stisknutí speciálních kláves (např. Escape = 27, Return = 13, Tab = 9, Backspace = 8).

Ve Windows módu se data z klávesnice vkládají prostřednictvím samostatných okének zobrazených příkazem InputRequester(), nebo pomocí vkládacích buněk vytvořených v rámci většího okna příkazem StringGadget().

; Příklad XXII; Název souboru: OBJEMOVKY.PB; výpočet objemové hmotnosti hranolovitých tělísek

OpenWindow(1, 300, 300,250,130,"Výpočet objemové hmotnosti", #PB_Window_SystemMenu)StringGadget(1,55,10,50,20,"")StringGadget(2,55,40,50,20,"")StringGadget(3,55,70,50,20,"")StringGadget(4,55,100,50,20,"")TextGadget(5,130,40,80,20,"")TextGadget(6,5,10,50,20,"Délka")TextGadget(7,5,40,50,20,"Šířka")TextGadget(8,5,70,50,20,"Výška")TextGadget(9,5,100,50,20,"Hmotnost")TextGadget (11,180,10,60,20, " ")RepeatUdalost = WaitWindowEvent ()If Udalost = #PB_Event_Gadget Vstup1 = ValF(GetGadgetText(1))Vstup2 = ValF(GetGadgetText(2))Vstup3 = ValF(GetGadgetText(3))Vstup4 = ValF(GetGadgetText(4))If Vstup1*Vstup2*Vstup3 > 0SetGadgetText (5,StrF (Vstup4 / (Vstup1 * Vstup2 * Vstup3))) ElseSetGadgetText (5," ")

- 63 -

EndIfEndIfUntil Udalost = #PB_Event_CloseWindowEnd

Příkazy Input(), InputRequester() i příkaz StringGadget() jsou použitelné pro vstup libovolného řetězce. Pokud mají sloužit jen pro vstup čísla je vhodné vkládaný řetězec podrobit kontrole formální správnosti ještě před jeho převodem na číslo [Příklad XXIII].

; Příklad XXIII; Název souboru: CISLOTEST.PBI; kontrola formální správnosti zadání čísla

Procedure.s Cislotest(String1$); odstranit mezery z testovaného řetězceString1$ = RemoveString(String1$, " ")PripustnaDelka=0 ; deklarace počáteční nulové hodnoty ( není povinná); přípustná délka se při následující analýze řetězce postupně zvyšuje

If Asc(String1$=43) or Asc(String1$=45)PripustnaDelka=PripustnaDelka +1 ; úvodní znaménko se podílí na délceEndIf

; nahradit čárku tečkou; (nutná úprava čísla zadaného z české numerické klávesnice)String1$ = ReplaceString(String1$, ",", "."); spočítat tečky a zohlednit jednu přípustnou tečkuIf CountString(String1$, ".") = 1 PripustnaDelka=PripustnaDelka +1 ; desetinná tečka se podílí na délceEndIf

; spočítat všechny číslice v testovaném řetězciFor i=0 To 9 PripustnaDelka=PripustnaDelka + CountString(String1$, Str(i))Next i; každá číslice se také podílí na délce; platný číselný řetězec nemůže být delší než je přípustná délkaIf Len(String1$)>PripustnaDelka String1$=""; pokud byl řetězec delší nahradí se prázdným řetězcem;( za proceduru se pak zařadí vhodné ošetření výstkytu prázdného řetězce)

- 64 -

EndIf; korektně zapsané číslo zůstává zachováno jako neprázdný řetězecProcedureReturn String1$EndProcedure

5.2.2 Vstup s pomocí myši

Vstup dat prostřednictvím myši je typický pro programy v prostředí Windows. Je výhodný zejména tehdy jestliže se jedná o vkládání dat v omezeném velikostním rozsahu. Nejsnáze se realizuje vkládání dat celočíselných. Používá se k tomu příkaz SpinGadget(), který ukazuje buňku s číslem, jehož hodnota se mění pomocí dvojice šipek. Pro čísla v rozsahu 0 – 10 000 je použitelný také příkaz TrackBarGadget(), jehož číselná hodnota se mění posunem posuvníku po zobrazené stupnici).

Ukázka použití SpinGadget() je uvedena dále [Příklad XXIV].

5.2.3 Vstup ze souboru

Pokud je soubor otevřen příkazem ReadFile(), lze ze souboru pouze číst. Pokud je k otevření použit příkaz OpenFile() je možné do souboru navíc také psát.

; Příklad XXIV; Název souboru: NUMLESS.PB; Tento program provádí odčíslování nebo naopak očíslování řádků ve zvoleném souboru; číslování je možné zadat s krokem 1 - 100; zdrojový soubor si zachová původní název; pokud bylo řádkování odstraňováno má upravený soubor k názvu přidanou číslici 1 ; pokud bylo řádkování přidáváno, je k rozšíření názvu použita číslice 2

Dim UlozenyRadek$(15)

ZDROJ:; proměnné Maska$ a Vzor slouží jako parametry příkazu ; OpenFileRequester, který otevírá menu pro výběr souboruMaska$ = "Basic source (*.bas)|*.bas;|All files (*.*)|*.*"

- 65 -

Vzor = 0 ; použijí se první dva prvky specifikované v Maska$ZdrojovySoubor$ = OpenFileRequester("NUMLESS 1.0" +Space(69)+ "© Luboš Svoboda 2008", StandardFile$, Maska$, Vzor)

; následující podmínka při stisku tlačítka Cancel nebo X v pravém rohu ;ukončí program (délka názvu souboru je v takovém případě nulová)

If Len(ZdrojovySoubor$) = 0 EndEndIf

DelkaSouboru = 0 ; tento příkaz zde nemusí být – výchozí hodnotou numerické proměnné je nula i bez tohoto příkazu (v PureBasic se provádí automatická inicializace)

If ReadFile(0, ZdrojovySoubor$) ; vložení příkazu pro čtení souboru ve formě podmínky zajišťuje, že nedojde k pokusu o zjišťování délky souboru, pokud by otevření pro čtení bylo neúspěšné DelkaSouboru = Lof(0) ; zjištění délky zvoleného souboru CloseFile(0)EndIf

If DelkaSouboru=0 StandardFile$ = "" Goto ZDROJ ; soubor nemá mít nulovou délku, proto se program vrací zpátky na možnost načíst nový souborEndIf

; vlastní otevření vybraného souboruOpenFile(0,ZdrojovySoubor$); soubor se otevře s identifikačním číslem 0

For i = 1 To 15 If Eof(0)=0 Precteno$ =ReadString(0) Precteno$ =LTrim(Precteno$) UlozenyRadek$(i) =Precteno$ EndIf ; pokud otevřený soubor 0 ještě nekončí, načte se řádek ; odstraní se z něj úvodní mezery; upravený řádek se uloží do indexované proměnnéNext i

; protože MessageRequester umožňuje zobrazit pouze jeden řetězec; vytvoří se řádkovaný text z uložených řádků pomocí Chr(13)

For i = 1 To 15 Ukazka$=Ukazka$+UlozenyRadek$(i)+Chr(13)

- 66 -

Next i; vzniklý text se doplní o úvodní údaj o souboru a o zakončující dotazUkazka$=ZdrojovySoubor$+Chr(13)+Chr(13)+Ukazka$+Chr(13)+Chr(13)+"MÁ UPRAVOVANÝ SOUBOR ČÍSLOVANÉ ŘÁDKY?"

CloseFile(0)OpenFile(0,ZdrojovySoubor$);nové otevření souboru zaručuje jeho čtení opět od začátku

Result = MessageRequester( "NUMLESS 1.0 Dotaz na formát",Ukazka$, #PB_MessageRequester_YesNoCancel)

If Result = #PB_MessageRequester_Yes ; stisknuto Yes (Ano); po stisku Ano se začne tvořit nový soubor bez čísel řádků NovySoubor$ = ZdrojovySoubor$ + "1" CreateFile(1,NovySoubor$) ; soubor s identifikačním číslem 1 While Eof(0) = 0 PocetRadku=PocetRadku+1 Precteno$ =ReadString(0) Precteno$ =LTrim(Precteno$) ; odstraněny úvodní mezery příkazem Ltrim ; následující smyčka zkracuje řádek o všechny úvodní číslice ; skončí v okamžiku kdy je prvním znakem něco jiného než 0-9 While Asc(Precteno$)>47 And Asc(Precteno$)<58 DelkaRadku=Len(Precteno$)-1 Precteno$= Mid(Precteno$,2,DelkaRadku) Wend ;zkrácený řádek se zapisuje do nového souboru s  extensí rozšířenou o 1 WriteStringN(1, Precteno$)

Wend Hlaseni$ = "Soubor s odstraněnými čísly řádků."

ElseIf Result = #PB_MessageRequester_No ; stisknuto No(Ne); po stisknu Ne se začne tvořit soubor s očíslovanými řádky NovySoubor$ = ZdrojovySoubor$ + "2" CreateFile(1,NovySoubor$)

If OpenWindow(0, 0, 0, 140, 70, "Číslovací krok", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) And CreateGadgetList(WindowID(0)) SpinGadget (0, 20, 20, 100, 25, 1, 100) ButtonGadget(1, 55, 48, 20, 20, "OK") ; v okně pro nastavení číslovacího kroku se objeví SpinGadget ; ve kterém se pomocí myši nastavuje celé číslo v rozsahu 1 – 100 ; nastavená hodnota se schvaluje tlačítkem OK; identifikační číslo pro tento gadget je 0

- 67 -

SetGadgetState (0, 1) SetGadgetText(0, "1") ; nastavení počáteční hodnoty a počátečního textu pro gadget 0 Repeat Event = WaitWindowEvent() If Event = #PB_Event_Gadget If EventGadget() = 0 SetGadgetText(0,Str(GetGadgetState(0))) EndIf If EventGadget() = 1 Nekoncim = 1 Event = #PB_Event_CloseWindow EndIf EndIf

Until Event = #PB_Event_CloseWindow EndIf ; nastavená hodnota se uloží do proměnné Krok Krok=GetGadgetState(0) If Nekoncim=0 End EndIf

While Eof(0) = 0

PocetRadku=PocetRadku+1 Precteno$ =ReadString(0) Precteno$ =LTrim(Precteno$) Precteno$= Str(PocetRadku*Krok)+" "+Precteno$

WriteStringN(1, Precteno$) ; očíslovaný řádek se zapisuje do souboru s  extensí rozšířenou o 2

Wend

Hlaseni$ = "Soubor s přidanými čísly řádků."

Else ; stisknuto Storno(Cancel) nebo Esc EndEndIf

Hlaseni$="Počet řádků: "+Str(PocetRadku)+Chr(13)+Chr(13)+Hlaseni$

CloseFile(1)OpenFile(1,NovySoubor$) For i = 1 To 15

- 68 -

If Eof(1)=0 Precteno$ =ReadString(1) Precteno$ =LTrim(Precteno$) UlozenyRadek$(i) =Precteno$ EndIfNext i

Ukazka$=""

For i = 1 To 15 Ukazka$=Ukazka$+UlozenyRadek$(i)+Chr(13)Next i

Hlaseni$=NovySoubor$+Chr(13)+Hlaseni$+Chr(13)+Chr(13)+Ukazka$

MessageRequester("NUMLESS 1.0 Upravený soubor", Hlaseni$, #PB_MessageRequester_Ok)

End

Souborem ze kterého jsou čtena data může samozřejmě být i vlastní program.

5.2.4 Import dat

Výhodným způsobem získání alfanumerických dat k dalšímu zpracování v PureBasic je jejich import z programu Microsoft Excell.

Na uživatelském fóru je dispozici knihovna COMatePLUS s jejíž pomocí byly vytvořeny PureBasic programy umožňující velmi detailní spolupráci s programem Micrososoft Excel.

COMatePLUS je PureBasic verzí oblíbeného freewarového programu DispHelper používaného programátory v C/C++ k usnadnění práce se softwarovými komponentami umožňujícími komunikaci jako t. zv.  COM objekty (ADO, CDO, Outlook, Eudora, Excell, Word, Internet Explorer, MSHTML, PocketSoap, Word Perfect, MS Agent, SAPI, MSXML,WIA, WMI a j.).

Stejně snadno jako je makrem možné vytvořit nové příkazy se s pomocí makra dá změnit i funkce stávajících příkazů.

V ukázkovém příkladu [Příklad XXIV] je pomocí makra modifkován příkaz PrintN() tak, že na každý řetězec zobrazovaný tímto příkazem na konzoli počítače, je nejprve aplikována procedura Prevod(), která zajistí správné zobrazení české diakrity. Vlastní zobrazení se pak provádí v makru

- 69 -

obsaženým příkazem Print(). Správné odřádkování textu se uskutečňuje pomocí residentní konstanty #CRLF$, kterou makro přidává ke každému zpracovávanému řetězci.

Tímto způsobem lze elegantně vyřešit fakt, že příkaz PrintN(), který se používá v konzolovém módu k zobrazení odřádkovaného textu, neprovádí odřádkování v tisku přesměrovaném do souboru.

; Příklad XXV; Název souboru: UPRAVPRINT.PBI

IncludeFile "PREVODNIK.PBI" ; vsune na toto místo text příkladu XIII

; s pomocí jazykového prvku Macro je předefinován příkaz PrintN; po načtení definice makra je rozšířen o transformační proceduru Prevod; tato procedura je pak použita na každý řetězec, který je argumentem PrintN ; upravený řetězec se pak následně tiskne příkazem Print; příkaz Print sám o sobě neprovádí odřádkování typické pro PrintN ; odřádkování se proto zajišťuje tiskem residentní konstanty #CRLF$

Macro PrintN(Jakykoliv) Prevod(Jakykoliv) Print(Vysledny$+ #CRLF$)EndMacro

; konstanta #CRLF$ je tvořená znaky Chr(13) +Chr(10); spolu s dalšími konstantami je uložena v souboru WindowsUnicode.res.

Výpočet v integrovaném vývojovém prostředí, který se provádí při

ladění programu, je o něco pomalejší, protože do času potřebného na řešení úlohy vstupuje i čas potřebný na kompilaci.

Demo verze PureBasic, která neumožňuje tvorbu samostatných exe souborů, proto není vhodná pro posuzování výpočetního výkonu.

- 70 -

5.3 Grafický výstup

PureBasic obsahuje celou řadu grafických funkcí. Má vlastní výkonnou grafickou 2D knihovnu a pro tvorbu 3D obrázků použivá knihovnu, která je konformní s open source standardem OGRE. Tato výbava souvisí s používáním PureBasic pro programování her. Při tvorbě vědeckotechnických aplikací je však využívání těchto schopností spíše zbytečné.

Programování vzhledově náročné grafického informace určené pro publikační využití je poměrně pracné. Je proto výhodné použít grafické funkce PureBasic jen pro průběžný grafický výstup a pro tvorbu grafů v publikační kvalitě využít spolupráci PureBasic s jiným programem.

Prakticky používaným příkladem programu s jednoduchým grafickým výstupem je program VICATDAT. Byl vyvořen jako

nadstavbový program k obslužnému software dodávanému k automatickému vícemístnému přístroji pro stanovení rychlosti tuhnutí cementu vpichovou zkouškou podle Vicata. Tento přístroj (BC VIC 03A) provádí potřebné měření v souladu s

normou ČSN EN 197-3. Originální obslužný software nedisponuje žádnou formou grafického

výstupu. Naměřené hodnoty data jsou ukládány do souborů *.wid (formát XML, kódování UTF-8). Tyto soubory mají svou specifickou strukturu a jejich obsah nelze jednoduše přímo načíst do textového editoru.

Ke zlepšení kvality výstupní informace byl proto vyvinut program VICATDAT, který provádí konverzi původního datového výstupu (formát XML) do přehledného protokolu (ve formátu txt), který lze snadno začlenit do libovolného textu. Konverzní program zároveň vytváří sloupcový diagram charakterizující průběh tuhnutí (ve formátu jpg).

Program při svém běhu vytváří miniaturní (1 kB) konfigurační soubor (Vicatdat.cfg), jehož editací je možné upravit barevný styl grafu a způsob popisu osy x. Pro běh programu tento soubor není nutný. V jeho

- 71 -

nepřítomnosti má barevný styl grafu a popis osy x základní podobu znázorněnou na vloženém obrázku.

5.4 Tvorba vlastních knihoven

S pomocí freeware aplikace Tailbite (35) je možné přidat k původ-ním knihovnám z dílny Fantaisie Software další knihovny vytvořené v

jazyku C nebo v assembleru.

Příkladem takové knihovny je RMChart sloužící k tvorbě obchod-ních grafů.

Knihovna RMChart User Lib v. 4.12 je dostup-ná jako freeware na uživatelském fóru.

5.5 Ladění a ošetření chyb

Při ladění programů se dá uplatnit trik spočívající v umístění příkazu End na první řádek zdrojového textu. Debugger v tomto případě provede kontrolu syntaxe, kompilátor provede kompilaci, ale program skončí dřív než začal. Nerozsvítí se žádná okna, nenatahují se žádné obrázky. V určité fázi ladění se tím může urychlit práce.

Pokusy o práci s neexistujícím souborem vedou k pádu programu. V PureBasic programech je proto dobrým zvykem používat OpenFile() ve formě podmínky.

Debugger PureBasic, který je součástí IDE disponuje řadou vyspělých funkcí usnadňujících ladění (on-line help, zvýrazňování párových prvků).

Velmi účinnou ladicí technikou je masivní používání příkazu Debug pro zobrazení obsahu proměnných, zobrazení průchodu přes kontrolní body a pro podmíněné zobrazování nejrůznějších komentářů.

Výtečnou pomůckou je možnost použít speciálních formát poznámek, který vznikne jednoduše tak, že se bezprostředně za úvodní středník poznámky umístí pomlčka. Odkaz na takto upravenou poznámku se objevuje v okénku Procedures, ve kterém IDE jinak zobrazuje pouze odkazy na procedury použité v programu. Ťuknutím na kterýkoliv ze zobrazených odkazů se nalistuje příslušné místo ve zdrojovém kódu.

- 72 -

U programů určených dalším uživatelům je nezbytné ověření funkčnosti programu nejméně jedním spolupracovníkem, který se přímo nepodílel na jeho tvorbě (41).

- 73 -

6. Používání PureBasic PureBasic byl původně vyvíjen pro použití v  počítačích Amiga,

které se svého času těšily oblibě především jako domácí počítače a multimediální hobby zařízení. PureBasic byl proto hned od počátku bohatě vybaven prostředky k podpoře multimediálních a grafických funkcí a celkově byl koncipován s důrazem na snadné

ovládání a vlídnost k uživatelům.I v oblasti PC / Windows se PureBasic nejprve uplatnil především

jako speciální prostředek pro programování her o čemž svědčí i první knižní publikace o PureBasic/Win věnovaná právě této oblasti (34).

Použitelnost PureBasic při zpracovávání vědecko-technických úloh byla zpočátku omezena tím, že pro výpočty s pohyblivou desetinnou čárkou byla k dispozici jen čísla s jednoduchou přesností.

Soudobý PureBasic však už tímto nedostatkem netrpí a mimořádná rychlost jeho zkompilovaného kódu se dnes může uplatnit i při výpočtech s většími nároky na přesnost.

Soudobý PureBasic poskytuje při řešení vědecko-technických úloh vysoký programátorský a uživatelský komfort. Jazyk sám je snadno pochopitelný a formálních omezení při psaní programového kódu je minimum. Bohaté příkazové knihovny nabízejí snadné řešení mnoha dílčích problémů.

Při vývoji PureBasic byla věnována velká péče tomu, aby kompilátor vytvářel rychlostně optimalizované soubory. Díky tomu PureBasic neklade na programátora

žádné zvláštní nároky ani v těch případech, kdy je v pomalejších jazycích nutné kvůli rychlosti ručně optimalizovat kód.

- 74 -

Dostatečně rychlé a uspokojivě fungující aplikace je možné začít vytvářet prakticky okamžitě.

Při programování rozsáhlejších aplikací se mohou uplatnit objektově orientové prvky, které lze do PureBasic s výhodou zavést s pomocí preprocesoru PureObject (36). S tímto doplňkem lze v PureBasic deklarovat třídy, definovat metody, vytvářet a rušit

objekty. Implementována je dědičnost, polymorfimus i zapouzdřování objektů.

Preprocesor PureObject nepochází přímo z dílny Fantasie Software, je však určitě zajímavým rozšířením možností, které PureBasic nabízí.

Na oficiálním uživatelském fóru a na webových stránkách mnohých uživatelů PureBasic je možné nalézt další volně využitelné programové knihovny a programování usnadňující utility.

Většina uživatelů PureBasic poskytuje vlastnoručně vytvořený kód jako open source software a umožňuje tak jeho využívání při další programové tvorbě.

6.1 Vyčíslení v IDE

Uživatelská vlídnost integrovaného vývojového prostředí jazyku PureBasic dovoluje používat IDE PureBasic k operativní tvorbě drobných výpočtových aplikací. Vlastnosti IDE se dají dobře využít jak k triviálnímu vyčíslení jednořádkového vzorce, tak pro miniaturní aplikace nahrazující programovatelnou kalkulačku.

Programy pro výpočty prováděné v IDE využívají k zobrazování výsledků příkaz Debug() a protože text programu je v IDE možné libovolně upravovat, připisují se do zdrojového kódu s výhodou i vstupní data ve formě proměnných s přiřazenou (snadno obměnitelnou) hodnotou [Příklad XXVI].

Do programu je samozřejmě možné přidat datový blok (ohraničený příkazy DataSection – EndDataSection) obsahující Data a obsluhovaný příkazy Read a Restore.

Při rozsahu do 65 řádků lze celý kód takové miniaturní aplikace pohodlně prohlížet v editačním okně IDE bez nutnosti rolování.

; Příklad XXVI; Název souboru: NAPETI.PB; výpočet napětí na styku betonu a polymerbetonové krycí vrstvy

- 75 -

; pro předem zvolený rozsah hodnot modulu pružnosti polymerbetonu Define.d ; výchozí typ všech proměnných bude DoubleDefine.i Ep ; řídící proměnná smyčky for-next musí být celočíselná

; koeficient lineární teplotní roztažnosti betonu (ab) a polymerbetonu (ap)ab=0.00001ap=0.00004 ; hodnota se upraví podle konkrétního typu polymerbetonu

; data pro určení maximálního rozdílu teploty při montáži a používání T1 = 23 ; teplota při montáži (kladení polymerbetonu)T2 = -20 ; minimální zimní teplota - platí pro exteriér ;T2=5 ; použije se při variantě pro výpočet v interiéru ; k interiérovému výpočtu stačí odstranit středník z předcházejícího řádku

; moduly pružnosti betonu (Eb) a polymerbetonu (Ep)Eb=40000; Ep – stupňovitě proměnná hodnota (viz následující smyčku)

For Ep = 2000 To 40000 Step 2000 ; van Vlackův vzorec pro výpočet napětí podlahové vrstvy Napeti=( (ap-ab)* Ep * Eb * (T1 - T2)) / (Ep+Eb) ; program bude spouštěn pouze v IDE – lze využít Debug Debug ("Modul Ep: "+ Str(Ep) + " Napeti: " +StrD(Napeti))Next Ep

; okénko Debug umožňuje uložit zobrazená data do textového souboru ; není tedy potřebné zde explicitně řešit jejich ukládání nebo tisk ; nekomentovaný program má proto jen 11 řádků

K menším variantním úpravám používaného programového kódu lze s výhodou využít přidávání a odebírání programových řádků s pomocí komentářových středníků.

Aplikace provozované v IDE jsou vhodné pouze pro vlastní potřebu autora zdrojového kódu. Pokud má vyčíslovací aplikaci opakovaně používat někdo jiný než autor, je lepší provést její úpravu do podoby konzolového programu a dalšímu uživateli (nebo uživatelům) jí poskytovat ve formě zkompilovaného exe souboru.

6.2 Drobné utility

Drobné utility mají podobný řádkový rozsah jako jednoduchá vyčíslení (1 - 102 řádků). S jejich pomocí jsou prováděny opakující se

- 76 -

obslužné operace, slouži ke snazšímu spouštění některých programů, nebo spojují více programů mezi sebou.

Opravdu velmi drobnou utilitou je jednoduchý „připomínač“ [Příklad XXVII].

; Příklad XXVII; Název souboru: miniREMINDER.PB A$="miniREMINDER.txt" If OpenFile(0, A$)  ; Otevře existující soubor, když neexistuje vytvoří prázdný soubor If Lof(0) > 6  MessageBeep_(48) ; příkaz Win API – systémový zvuk „Vykřičník“    RunProgram(A$) EndIfEndIf

Soubor vzniklý kompilací příkladu XXVII (miniREMINDER.exe) při prvním spuštění vytvoří (v adresáři ve kterém je uložen) prázdný sou-bor miniREMINDER.txt.

Zástupce souboru miniREMINDER.txt se umístí na ploše, takže je tento soubor možné kdykoliv snadno editovat. Zstupce souboru miniREMINDER.exe se umístí do skupiny Ke spuštění.

Při každém spuštění počítače pak program kontroluje velikost souboru miniREMIDER.txt a pokud je v něm nějaký text spustí akustický signál a rozsvítí okénko souboru. Součástí řetězce A$ samozřejmě může být i cesta a soubor miniREMINDER.txt, lze pak vytvořit prakticky kdekoliv ( s výhodou na ploše – odpadá potřeba zástupce).

Trochu složitější je utilita pro dávkový tisk souborů PDF [Příklad XIX].

6.3 Malé programy

Typickým způsobem využití PureBasic při vědecko-technické činnosti je tvorba programů o velikosti 102 – 103 řádků.

Úlohy obsahující stovky řádků už nemohou být snadno naprogramovány na kapesní kalkulačce, ale z hlediska PC jsou to stále úlohy malé.

- 77 -

Nejčastějším účelem těchto malých programů je usnadnění a zpříjemnění často opakované výpočetní činností, kterou by jinak musel provádět buď sám autor programu, nebo někdo z autorova okolí.

K tomu aby malé programy dobře plnily svoji funkci nelze při jejich psaní pominout chybové ošetření a náležitou péči je třeba věnovat i vzhledu a uživatelské vlídnosti příslušné aplikace.

Ukázkou malé konzolové aplikace je program DDtest, který je určen pro základní statistické ošetření (Dean-Dixonův test) souboru obsahujícího 3 – 9 paralelních stanovení.

Přibližně třetinu kódu tohoto programu tvoří univerzální procedury, které zajišťují správnou diakritiku zobrazovaného a ukládaného textu a dobře čitelný formát číselných výsledků.

I když stejné statistické ošetření je možné provést v rámci řady větších programových statistických balíčků předsta-vuje DDtest dobře přenosný a rychle spustitelný program vhodný pro rutinní používání. V případech, kdy jeden počítač užívá

více lidí, umožňuje nepatrná velikost kompilovaného souboru, aby každý uživatel měl na počítači svůj adresář se svou kopii programu.

V programu proto není řešeno nastavení cesty pro ukládání výsledků a výsledky se ukládají vždy do adresáře programu.

Zdrojový kód programu má 480 řádků (vložené univerzálních procedury zaberou dalších 220 řádků). Protože jde o konsolovou a tudíž z hlediska kódování velmi jednoduchou aplikaci, není zde zdrojový kód uváděn. Jako plně funkční freeware je program DDtest k dispozici na webových stránkách autora. PureBasic je rychlý a má proto dobré vlastnosti i při zpracovávání většího množství dat. Příkazy pro práci s řetězci usnadňují tvorbu a zpracování datových souborů založených na textových řádcích.

Ukázkou malé Windows aplikace je program POPELKA 1.8, který byl vyvinut k prohledávání přehledu českých technických norem. Zdrojový kód programu má 254 řádků.

- 78 -

Přehled ČSN se kterým program pracuje má podobu řádkové databáze, která obsahuje asi 47 000 řádků o prů-měrné délce 100 znaků. Každá norma má svůj samostatný řádek.

Databázi je sice možné prohlížet s pomocí textového editoru, ale získávat s použitím běžné vyhlédavací funkce textového editoru nějaký rozsáhlejší soupis výskytů hledaného klíčové slova či sousloví je pracné.

Vytváření soupisů mapujících výskyt nějakého termínu se neobyčejně zrychlí při použití programu POPELKA, který z řádků obsahujících hledaný termín vytváří souhrnný textový soubor, který se okamžitě zobrazuje a zároveň automaticky ukládá.

Rychlost prohledávání činí v případě dotazu tvořeného dvěma slovy asi 100 000 řádků za sekundu (P4 - 1.6 GHz) a výsledek rešerše se na obrazovce objeví během dvou vteřin.

; Příklad XXVIII (PB 4.20); Název souboru: POPELKA 1_8.PB; vyhledávací utilita spolupracující s programem Notepad; v úvodním okně se nejprve vybere soubor textového typu; po zadání minimálně jednoznakového dotazu; POPELKA ve zvoleném souboru prohledává řádek po řádku; řádky obsahující všechna slova dotazu vypisuje do výsledkového souboru ; slova se mohou v prohledávaném řádku vyskytovat kdekoliv; sousloví (dvojice slov oddělené pevnou mezerou) se hledají pomocí %% ;; (dvojitá procenta v dotazu při vyhledávání představují jednu mezeru); prázdný dotaz program ukončuje; program obsahuje ochranu proti načtení prázdného zdrojového souboru; v programu jsou tři návratové body (návěští) používané příkazem Goto ; použit příkaz CharUpper_() pocházející z Windows API

AdresarPopelky$=GetCurrentDirectory()Dim Slovo$(50)

If CreateDirectory(AdresarPopelky$+"POPEL")EndIfDirectory$ = AdresarPopelky$+"\POPEL\"

StandardFile$ = "Vyberte soubor, ve kterém bude hledáno !" ; místo přednastaveného souboru se v příkazu OpenFileRequester zobrazí; výzva k vyhledání vhodného zdrojového souboru

; následující řetězec Maska$ slouží k nastavení typu souborů v adresáři,; které bude příkaz OpenFileRequester nabízet k otevření

- 79 -

; ("|" slouží jako separátor jednotlivých typů) ; 1. zobrazí se nabídka "Text (*.txt)", a příslušné textové soubory; 2. zobrazí se nabídka "All files (*.*) a všechny soubory

Maska$ = "Text (*.txt)|*.txt;|All files (*.*)|*.*"Vzor = 0 ; použij první ze dvou možností nabízených v Maska$

; zde se vybírá soubor ze kterého se budou číst data porovnávaná s dotazemZDROJ:Zdrojovy$ = OpenFileRequester("Popelka 1.8 © Luboš Svoboda 2007", StandardFile$, Maska$, Vzor)

; následující podmínka ukončí program když se stiskne tlačítko Cancel,; nebo tlačítko X v pravém rohuIf Len(Zdrojovy$) = 0 End EndIf

If Zdrojovy$ If ReadFile(0, Zdrojovy$) DelkaSouboru = Lof(0) ; zjištění délky otevřeného souboru CloseFile(0) EndIf EndIf

If DelkaSouboru=0StandardFile$ = ""Goto ZDROJ ; soubor nemá mít nulovou délku; proto se musí skočit zpět a načíst nový souborEndIf

For i = 1 To Len(Zdrojovy$) BezCesty$ = BezCesty$+ Mid(Zdrojovy$,i,1) If Mid(Zdrojovy$,i,1) ="\" BezCesty$= "" EndIf Next i If Len(BezCesty$) > 0 Tecka = FindString(BezCesty$, ".",1) If Tecka > 0 Podadresar$ = Left(BezCesty$,Tecka-1) EndIf Podadresar$=AdresarPopelky$+"POPEL\"+Podadresar$ If CreateDirectory(Podadresar$) Else EndIf

- 80 -

EndIf

If Len(BezCesty$) >30 Database$ = Left(BezCesty$,27)+ "..."Else Database$= BezCesty$EndIf

Database$ = Space(30-Len(Database$))+Database$

Titul$ ="Vlož hledanou část slova ! Prázdný řádek ukončí dotazy."

ZNOVA:RadkyCelkem=0RadkyPrazdne=0RadkyVyznamne=0PuvodniDotaz$ = InputRequester("Popelka 1.8 "+Database$, Titul$, "")

Dotaz$ = LTrim(PuvodniDotaz$) ; odstranit mezery vpředu Dotaz$ = RTrim(Dotaz$) ; i vzadu

While CountString(Dotaz$," ") ; když jsou 2 mezery za sebou Dotaz$ = ReplaceString(Dotaz$," "," ") ; nahraď 2 mezery jednou Wend ; opakuj kontrolu přítomnosti dvou mezer

CharUpper_(Dotaz$) ; všechna písmena v dotazu budou velká; nebyl použit příkaz UCase, protože nepřeváděl správně š,ť,ž

If Dotaz$ = "" ; dotaz nulové délky se pokládá za návrh k ukončení hledání v souboru

Result = MessageRequester("Popelka 1.8", "Ukončit program ?", #PB_MessageRequester_YesNo) ; jazyk dotazu MessageRequester je dán jazykem operačního systému OTAZKA:

If Result = #PB_MessageRequester_Yes ; stisknuto Yes (Ano) End ; program se ukončí ElseIf Result = #PB_MessageRequester_No ; stisknuto No(Ne) StandardFile$ = "" Goto ZDROJ ; znovu se nabídne adresářové okénko pro načtení nového souboru Else Goto OTAZKA ; stisknutí Cancel (Storno) nebo Esc otázku nezruší EndIf EndIf

- 81 -

; dotaz byl zkontrolován a nemá nulovou délkuDotaz$ = Dotaz$ +" " ; přidá se jedna mezera, ukončující poslední slovo v dotazu; v tomto okamžiku je každé slovo v dotazu ukončeno právě jednou mezerou; mezera tedy může být použita ke zjištění konce slova

SetCurrentDirectory(Podadresar$)

; soubor do něhož se ukládá výsledek bude mít jméno odpovídající dotazu; přípustný název souboru nesmí obsahovat * ? : / > < \ "; tyto znaky se proto v názvu souboru nahrazují slovním vypsánímPripustny$=ReplaceString(Dotaz$,"*", " hvezdicka ")Pripustny$=ReplaceString(Pripustny$,"?"," otaznik ")Pripustny$=ReplaceString(Pripustny$,":"," dvojtecka ")Pripustny$=ReplaceString(Pripustny$,"/", " lomitko ")Pripustny$=ReplaceString(Pripustny$,"\", " zpetne lomitko ")Pripustny$=ReplaceString(Pripustny$,">", " vetsi nez ")Pripustny$=ReplaceString(Pripustny$,"<", " mensi nez ")Pripustny$=ReplaceString(Pripustny$,Chr(34), " uvozovky ")

If CreateFile(1, Pripustny$+".txt") ; vytvoří se soubor o názvu vytvořeném z textu dotazu ; nepřípustné znaky jsou nahrazeny slovy Else MessageRequester("Nejde vytvořit soubor:", Pripustny$+".txt") ; tato eventualita by normálně neměla nastat – ošetřena je zde „pro jistotu“ Goto ZNOVAEndIf

If ReadFile(0, Zdrojovy$) ; jestliže jde přečíst soubor tak pokračujeme…

Tvoreny$="" Pocetslov=0

For i = 1 To Len (Dotaz$) ; dotaz se uloží po slovech do indexovaných proměných Slovo$(i) If Mid(Dotaz$,i,1) = " " ; čte jeden znak z i-té pozice v řetězci dotazu Pocetslov=Pocetslov+1 Slovo$(Pocetslov) = Tvoreny$ Tvoreny$="" Else Tvoreny$ = Tvoreny$+ Mid(Dotaz$,i,1) ; dokud se neobjeví mezera, tvoří se Tvoreny$ EndIf Next i

- 82 -

For j = 1 to PocetSlov Slovo$(j)=ReplaceString(Slovo$(j),"%%"," ") Next j ; zdvojená procenta se užívají jako pevná mezera k hledání sousloví

Zacatek = ElapsedMilliseconds() ; specifická funkce udávající počet milisekund od startu počítače

While Eof(0) = 0 ; smyčku provádět dokud se nedojde na konec souboru PuvodniRadek$=ReadString(0) RadkyCelkem =RadkyCelkem+1 If Len(PuvodniRadek$)=0 RadkyPrazdne = RadkyPrazdne +1 Else ; hledat má smysl v jen v neprázdných řádcích Radek$ = PuvodniRadek$ CharUpper_(Radek$) ; všechna písmena v řádku budou velká Vyskyt =1

For j = 1 to PocetSlov Vyskyt = FindString(Radek$, Slovo$(j),1) If Vyskyt = 0 ; pokud v řádku právě hledané slovo chybí Break ; další slova se nehledají - Break ukončí provádění smyčky EndIf Next j

If Vyskyt > 0 ; jestliže byla v řádku všechna hledaná slova přítomna, řádek je významný RadkyVyznamne = RadkyVyznamne+1 If RadkyVyznamne = 1 ; při prvním výskytu významného řádku se vytvoří hlavička WriteStringN (1, " ") WriteStringN (1, "Zdrojový soubor: "+ Zdrojovy$) WriteStringN (1, "Hledáno: "+ PuvodniDotaz$) WriteStringN (1, " ") WriteStringN (1, "Výsledkový soubor: ") WriteString(1, Podadresar$+"\"+Pripustny$+".txt") WriteStringN (1, " ") EndIf WriteStringN (1, PuvodniRadek$) ; významné řádky se zapisují EndIf EndIf Wend

- 83 -

Trvalo = ElapsedMilliseconds() -Zacatek ; doba prohlížení databázového souboru PocetRadkuVyznamnych$= Str(RadkyVyznamne) PocetRadkuCelkem$= Str(RadkyCelkem) PocetRadkuPrazdnych$= Str(RadkyPrazdne)

If RadkyVyznamne > 0 WriteStringN (1, " ") WriteStringN (1, "Počet řádků výsledku: "+ PocetRadkuVyznamnych$) WriteStringN (1, " ") WriteStringN (1, "Počet řádků zdroje: "+ PocetRadkuCelkem$ ) WriteStringN (1, "Počet prázdných řádků: "+PocetRadkuPrazdnych$) WriteStringN (1, "Potřebný čas: "+ str(Trvalo) +" ms")

EndIf

CloseFile(0) ; zavři oba dříve otevřené soubory CloseFile(1)

EndIf

Adres$=GetCurrentDirectory()

If RadkyVyznamne > 0 ; jestliže vyhověl alespoň jeden řádek ; pak má smysl spouštět externí program zobrazující vyhovující řádky RunProgram("Notepad.exe",Pripustny$+".txt",Adres$) ; Notepad zobrazí výsledek EndIfTitul$ = Pripustny$ + ".txt: " + PocetRadkuVyznamnych$ + " Další ?"

Goto ZNOVAEnd

6.4 Programy střední velkosti

Příležitostné programování není týmovou záležitostí a plánovaná tvorba středně velké aplikace obsahujících několik tisíc řádků je pro jednoho pracovníka, který se programování navíc může věnovat jen v části své pracovní doby, již poměrně ambiciózním projektem.

S využitím rozsáhlých programových ukázek, dostupných jako public domain v uživatelském fóru, je však příležitostná tvorba funkčních a vzhledově uspokojivých aplikací střední velikosti docela dobře možná.

- 84 -

Příkladem může být freewarové řešení Nelder-Meadovy optimalizace dostupné na webo-vých stránkách autora. Zdrojový kód exe souboru programu SOVA má 5500 řádků.

Programy střední velikosti však vznikají při příležitostném pro-gramování často jakýmsi původně neplánovánovaným růstem. Dochází k němu postupným

přidáváním nových funkcí a modifikací do dříve vytvořeného a osvědčeného programu.

Zde je na místě uložit si určitou programátorskou kázeň a nenechávat svépomocně vypracované programy zbytečně narůstat. Zachovávat „polibkové pravidlo“ (Keep It Short and Simple) je žádoucí především s ohledem na budoucí údržbu kódu.

Při integraci několika samostatných programů do většího celku je lepší ponechat jednotlivé spustitelné programy v původní podobě a  integrované ovládání uskutečnit pomocí samostatného řídícího programu, jehož menu těmto progra- mům „vládne“.

Ve všeobecné knihovně PureBasic se nachází příkaz RunProgram(), který umožňuje spouštět programy velmi flexibilním způsobem.

6.5 Rozsáhlé úlohy

Pro opravdu rozsáhlé úlohy se PureBasic nepoužívá. Celkový rozsah editovaného kódu sice může být až 16 777 215 řádků, ale ani největší dosud vytvořené PureBasic programy se výše uvedenému řádkovému maximu zdaleka nepřibližují. Dosud nejrozsáhlejší zdrojový kód má pravděpodobně program PureVision - profesionálně vytvořené graficky orientované vývojové prostředí (okolo 50 000 řádků). V rámci příležitostného programování není ani takový rozsah příliš pravděpodobný,

- 85 -

7. Celkové hodnocení Celkové hodnocení jazyku PureBasic je

prováděno z hlediska jeho budoucího uži-vatele, přičemž se předpokládá, že primárním zájmem tohoto uživatele je osobní využívání PureBasic při operativní tvorbě malých a středních aplikací, převážně technického, nebo ekonomického charakteru.

Typickým uživatelem ve smyslu tohoto předpokladu je příležitostný programátor, který vytváří takové aplikace pro svou osobní

profesní potřebu. Při uživatelském hodnocení software se doporučuje věnovat

pozornost následujícím charakteristikám (37):

• Použitelnosti (způsobilosti řešit dané problémy)

• Flexibilitě (snadnosti adapce na řešeni modifikovaného problému)

• Rozšiřitelnosti (možnosti připojování nových komponent a periferií)

•Portabilitě (přenositelnosti mezi různými počítači)

• Interkonektivitě (schopnosti práce v síti)

• Účinnosti (výpočetnímu výkonu, zejména jeho rychlosti a přesnosti)

• Snadnosti používání

• Bezpečnosti (ochraně proti neoprávněnému zásahu)

• Spolehlivosti

• Snadnosti údržby

• Velikosti aplikací (s ohledem na objem zdrojového kódu a dat)

• Bohatosti zázemí (uživatelské fórum, sbírky programů, tutoriály)

• Ceně (nákladům na pořízení a upgrade)

• Pověsti (všeobecná známost, příznivé recenze, postavení na trhu)

- 86 -

7.1 Silné stránky

Použitelnost PureBasic k řešení technických problémů je velmi dobrá. PureBasic je dostatečně bohatý na různé datové typy a jeho knihovny obsahují mnoho užitečných funkcí.

Kompilátor jazyku PureBasic produkuje velmi rychlý kód. Ten se uplatňuje především při provádění optimalizačních a simulačních úloh pro které je velký objem výpočtu typický. V tomto směru je PureBasic mnohem výkonější než běžné skriptovací jazyky.

Přesnost provádění výpočtů je díky možnosti používání proměnných typy double precision velmi uspokojivá.

Snadnost používání PureBasic je mimořádná. Při prohlížení internetového fóra uživatelů PureBasic často zjistíme, že obsahem prvního příspěvku nového uživatele je touha rozdělit se o překvapení nad tím jak rychle a lehce je možné začít v PureBasic programovat a řešit praktické problémy.

Zvláště blízký je PureBasic lidem, kteří za sebou mají zkušenosti s programováním v některém z DOS dialektů jazyku BASIC. Těm PureBasic umožňuje se k programování relativně snadno vrátit.

Předchozí programátorská zkušenost však rozhodně není pro rychlé zahájení práce podmínkou. K jazyku PureBasic existuje bohatá uživatelská dokumentace a silnou pomoc pro každého nového uživatele představuje perfektně fungující uživatelské fórum.

Pro rychlé osvojení jazyku má svůj význam uživatelsky přátelské procedurální paradigma, díky kterému může být programování v PureBasic mnohdy vnímáno jako aktivní odpočinek.

Klasický strukturovaný kód je svojí stavbou blízký přirozenému myšlení a může být modifikován relativně snadno. Snadnost úpravy programového kódu

a snadná tvorba programových variant patří proto rovněž k přednostem PureBasic.

Bezpečnost proti neoprávněnému zásahu do programového kódu PureBasic aplikací je dobrá, protože kompilovaný kód není přímo čitelný a pro dekompilaci a modifikaci jednotlivých exe souborů není k dispozici žádný obecně dostupný nástroj.

Purebasic je tedy na tom s bezpečností aplikačního kódu lépe než jazyky pracující s bajt kódem (Java) nebo mezikódem CIL (.NET)

- 87 -

Ke ztížení nežádoucích editačních zásahů je navíc možné využít některou z freewarových aplikací pro kryptovanou komprimaci exe souborů. Vhodný je program UPX (Ultimate Packer for eXecutables), nebo méně známý (ale velmi účinný) yoda’s Crypter (38, 39).

Zkompilované exe soubory jsou mimořádně malé. Zdro-jový kód dříve uvedeného testu GAMMIX [Příklad I] vytváří po kompilaci exe soubor o velikosti jen 6 kB, což je soubor, který je šestkrát menší než soubor vznikající při kompilaci testu GAMMIX klasickým DOS kompilátorem TurboBasic 2.0 od firmy Borland.

Exe soubory nevyžadují instalaci a PureBasic je proto ideální nástroj pro tvorbu fyzicky snadno přenosných aplikací („software do klíčenky“).

Zdrojové soubory jsou snadno přenosné i mezi třemi hlavními operačními systémy. Stejný zdrojový soubor je možné zpracovat třemi různými kompilátory. Tyto kompilátory jsou přitom dostupné v rámci jedné licence.

Význam softwarové portability desktopových aplikací nelze v našich podmínkách přeceňovat, protože přes 97 % osobních počítáčů pracuje s OS Windows (40), ale pro vyznavače obou alternativních OS je tato portabilita důležitá.Pokud jde o chopnost práce v síti je PureBsic plně vybaven speciálními příkazy pro síťovou komunikaci. Jsou umístěny ve dvou samostatných knihovnách Mail a Network.

- 88 -

Ze čtrácti Raymond –Rolandových charakteristik se tedy většina nachází mezi silnými stránkami.

7.2 Slabé stránky

Slabou stránkou PureBasic jistě je fakt, že se jedná o komerční (proprietární) software a je tedy nutné si ho koupit. Doživotní licence na používání PureBasic je však nabízena za velmi příznivou cenu a v rámci této licence získává uživatel jazykové verze pro všechy podporované operační systémy a doživotní bezplatný upgrade.

Frewarové projekty sice nevyžadují žádné pořizovací náklady, ale při bližším pohledu je zřejmé, že jejich vlastnosti nedosahují úrovně PureBasic. Často se jedná o crippleware obsahující nenápadná omezení, která nakonec uživatele donutí k pořízení placené verze.

Nevýhoda komerčního charakteru PureBasic je do určité míry změkčena tím, že demo verze programu je dostupná zcela volně. Na „osahání si“ tedy není nutné vynakládat žádné prostředky.

Zda má být za slabou stránku PureBasic považována jeho relativní neznámost je sporné. Na jednu stranu sePureBasic nemůže těšit z cílené podpory tvůrců jiných aplikací na straně druhé tento nezájem snižuje možnost nepřátelského převzetí.

7.3 Příležitosti

Uživatelé PureBasic spolu komunikují převážně prostřednictvím uživatelského fóra. Toto fórum je vedeno velmi liberálně.

Od nového účastníka je požadován pouze e-mail a přezdívka (nickname).

Každý účastník může přidat ještě místo odkud pochází, odkaz na vlastní webové stránky a jednoduché logo (avatar). Maximální rozměr avataru je 80 x 80 px.

E-mail se běžně nezveřejňuje. Je uložen v neveřejné části fóra, která ale umožňuje výměnu privátních sdělení mezi přihlášenými účastníky fóra, aniž by museli znát své e-mailové adresy.

Pokud si účastník fóra přeje svůj e-mail zveřejnit, nebo přidat i další údaje má pro tento účel k dispozici okénko, které se zobrazuje pod každým příspěvkem. Obsah okénka (profilu) je v zásadě libovolný, převládají však osobní slogany a bližší popisy používaného hardware.

- 89 -

Velká část účastníků uvádí při přihlašovaní do fóra jen povinné údaje. U většiny účastníků je proto v seznamu uživatelů vidět pouze nickname a případně i avatar.

Pokud místo původu účastníci vůbec vyplní, uvádějí zde kromě zemí i města, ale třeba také „svět“. Zjistit zde skutečný počet uživatelů z určité země (třeba z Česka) není tedy možné.

U každého uživatele fóra, který se účastní diskuze, se zobrazuje datum kdy se do fóra přihlásil a celkový počet jeho diskuzních příspěvků. K rychlému zhodnocení aktivity příslušného uživatele slouží „hodnosti“, které jsou automaticky přidělovány podle počtu příspěvků.

Fórum bohužel není dostupné off-line, což sice není na závadu při běžné diskuzi, nebo při jednoduchém hledání, ale komplikuje to hlubší rozbor uživatelské i věcné struktury fóra.

V on-line provozu je (vcelku pochopitelně) k dispozici vždy jen jedna zobrazovaná stránka.

Například ke zjištění, že z celkového počtu 3528 účastníků fóra (stav přihlášených k 1. 10. 2009 ) se nadpoloviční většina (58 %) aktivně účastní svými vlastními příspěvky, bylo třeba postupně ručně načítat jednotlivé stránky  seznamu uživatelů setříděného podle počtu příspěvků.

Platforma uživatelského fóra je pro každého účastníka mimořádnou příležitostí umožňující zefektivnit a usnadit programování v PureBasic. Samozřejmě, že studiem setříděného seznamu je i v on-line provozu možné získat zajímavé informace. Přínosná může být kupříkladu návštěva webových stránek (osobních nebo firemních) nejaktivnějších členů.

Liberální způsob vedení fóra dává dobré předpoklady pro zřízení v podstatě libovolně orientované zájmové platformy.

7.4 Hrozby

Fantaisie Software je drobnou firmou, která svou existencí neohrožuje velké softwarové společnosti. Je proto jen málo pravděpodobné, že by došlo k jejímu nepřátelskému převzetí. Fantaisie Software navíc ani nemá charakter veřejně obchodované společnosti a převzetí by se tedy muselo uskutečňovat koupí přímo od majitele.

Majitelem firmy Fantaisie Software je Frederic Laboureur.

- 90 -

Frederic Laboureur je zcela určitě mimořádně schopný programátor, který při vývoji a dalším zdokonalováním PureBasic odvedl výtečnou práci.

PureBasic byl původně jeho studentský projekt, na Université Pierre et Marie Curie v Paříži. Tento projekt se nakonec ukázal natolik životaschopný, že k jeho dalšímu rozvoji mohl v roce 2001 založit vlastní firmu.

Marketingové řízení firmy Fantaisie Software není u F. Laboureura na prvním místě. Zjevně daleko více ho uspokojuje práce hlavního kodéra a administrátora oficiálního uživatelského fóra PureBasic.

Zřejmě proto je firma provozována velmi minimalisticky. Nemá žádné viditelné obchodní oddělení a  nikdo se na plný úvazek nestará o její propagaci.

Z diskuzí na uživatelském fóru je zřejmé, že F. Laboureur není nakloněn zavádění nějakého obchodně účinnějšího způsobu fungování firmy. Přátelský a neformální přístup k uživatelské komunitě mu zřejmě vyhovuje. Výslovně odmítl zavést do instalačního programu ochranu proti kopírování a spoléhá na poctivý přístup jednotlivých držitelů osobních licencí.

Frederic Laboureur je mladý (* 1978) a má ještě větší část svého pracovního i osobního života před sebou. Jeho odchod do důchodu v blízké době opravdu nehrozí.

Samozřejmě že nelze vyloučit opuštění firmy kvůli změnám v osobním životě nebo v osobním hodnotovém žebříčku.

Sám F. Laboureur prohlásil, že v práci na PureBasic hodlá pokračovat, ale pokud by někdy opustil PureBasic, uvolní příslušné zdrojové kódy jako open source software.

Pro účastníky uživatelského fóra by odchod „Freda“ byl jistě citelnou ranou, protože zde představuje všeobecně uznávanou autoritu a závažnější problémy účastníků pomáhá řešit s velkým osobním nasazením.

Je však pravděpodobné, že by takový krok neznamenal náhlý zánik uživatelské komunity. Na fóru je celá řada každodenních účastníků s náležitou kvalifikací a erudicí.

Současný PureBasic je natolik vyzrálý programovací systém, že lze oprávněne předpokládat jeho dlouhodobou použitelnost i v případě zpomalení nebo zastavení jeho dalšího vývoje.

- 91 -

8. Závěr

Informace obsažené v této studii mají zájemcům o svépomocné programování pomoci při rozhodování o tom, zda je PureBasic vhodným programovacím prostředkem pro jejich potřebu.

V předcházejících kapitolách této studie byla demonstrováno, že vlastnosti a možnosti jazyku Pure Basic umožňují jeho použití pro vědecko-technické aplikace a že toto použití je překvapivě snadné.

Při práci s PureBasic v prostředí Windows jsou k dispozici všechny prostředky standardního jazyku BASIC a všechny funkce obsažené v API Windows.

PureBasic je jazyk, který účelně využívá nejrůznější open source zdroje (flat assembler, Scintilla editor, Orgre grafiku, Tailbite knihovny)

Díky tomu a díky vlastním bohatým a promyšleně konstruovaným knihovnám představuje PureBasic programovací prostředek použitelný pro nejrůznější účely.

I když metody OOP nejsou v PureBasic nedostupné je pravděpodobné, že většina příležitostných programátorů se ráda přidrží tradiční procedurální koncepce tvořící základ PureBasic.

Zcela mimořádný fenomén představuje uživatelské fórum PureBasic. Jedná o velmi přátelskou aktivní komunitu, která je silně ovlivněna duchem open source a uživatelům PureBasic poskytuje účinnou pomoc.

Je pochopitelné, že PureBasic nebude představovat optimální řešení pro každého. Pro jednoduché tabulkové výpočty je možné zůstat u některého ze soudobých spreadsheetů ( Microsoft Excell, OpenOffice Calc) a vynikající služby mohou poskutnout i specializované matematické programy (Mathematica, MatLab, Maple). Do značné míry bude záležet i na tom jaké usilí už potencionální uživatel vložil do zvládnutí jiného programovacího prostředku.

Rozhodně však platí, že akronymický výklad názvu jazyku BASIC (Beginner's All-purpose Symbolic Instruction Code) je v případě PureBasic mimořádně výstižný. Je těžké najít jiný programový prostředek, který by byl tak snadno osvojitelný a přitom tak univerzální.

- 92 -

9. Literatura

1. PureBasic : visual basic compiler, easy & optimized basic programming language http://www.purebasic.com/index.php [Získáno: 22.8.2009]

2. ČSN EN 26373:1996 Informační technika - Programovací jazyk - Minimální BASIC.

3. Kurtz, T. E.: BASIC. In: ACM Sigplan Notice 1978, vol. 13 (8), p. 103 – 118.

4, Richard M. Jones: Structured BASIC, Allyn and Bacon, Inc. Boston, 1985. 419 s.

5. Toonski : PureBasic Maker Speaks Out. In: www.vplanetmag.com/arch201.shtml 9. 3. 2002. [Získáno: 25. 2. 2009]

6. http://en.wikipedia.org/wiki/FASM [Získáno: 26.2.2009]

7. Hrach, R.: Počítačová fyzika I, PF UJEP , Ústí nad Labem 2003. 137 s.

8. Beer, A.: Interview with Frédéric 'AlphaSND' Laboureur. In: http://www.purearea.net/pb/english/interview.htm [Získáno: 28.2. 2009]

9. http://www.purearea.net/pb/english/interview_fred_2012.htm [Získáno 30.1. 2013]

10. http://www.purebasic.com/onlineordering.php3 [Získáno: 26.8.2009]

11. http://www.purebasic.com/download.php [Získáno: 26.8.2009]

12. http://www.purebasic.com/documentation/PureBasic.pdf [Získáno: 26.8.2009]

13. http://www.purebasic.com/documentation/index.html [Získáno: 26.8.2009]

- 93 -

14. http://www.purebasic.fr/english/ [Získáno: 26.8.2009]

15. http://www.purebasic.fr/german/ [Získáno: 30. 1. 2010]

16. http://www.purebasic.fr/french/ [Získáno: 30. 1. 2010]

17. http://www.purebasic.de/ [Získáno: 30. 1. 2010]

18. www.purearea.net [Získáno: 30. 1. 2010]

19. www.purebasic.be [Získáno: 30. 1. 2013]

20. http://freak.purearea.net/ [Získáno: 6. 7. 2008]

21. Horst Schaeffer's Software Pages [Získáno: 30. 1. 2013]

22. www.robsite.de/tutorials.php?tut=purebasic [Získáno: 6. 2. 2007]

23. http://www.xs4all.nl/~bluez/datatalk/pure1.htm

24. http://drac.site.chez-alice.fr/Tutorials%20Programming%20PureBasic/indexTutorials_en.htm

25. http://pureproject.reelmedia.org/

26. Willoughby, G.: Purebasic, Aardvark Global Publishing, Salt Lake City 2006. 348 s.

27. http://pb-beginners.co.uk/

28. http://www.scintilla.org/ [Získáno: 5. 9. 2009]

29. http://freenet-homepage.de/gnozal/#PureFORM [Získáno: 7. 9. 2009]

30. www.reelmediaproductions.com/purevision

31. http://www.hellobasic.com/pbdev/ [Získáno: 30. 1. 2013]

32. http://www.crimsoneditor.com/ [Získáno: 30. 1. 2013]

- 94 -

33. http://gnozal.ucoz.com/ [Získáno: 30. 1. 2013]

34. Logsdon, J. P. : Programming 2D Scrolling Games, Idigicon 2005. 310 s.

35. http://www.tailbite.com/

36. http://pb-oop.origo.ethz.ch/

37. Raymond, C. R. – Ronald, J. R. „ Inteligent Software for Product Formulation, Taylor & Francis, London 1998. 250 s.

38. http://www.slunecnice.cz/sw/upx/

39. http://www.programmersheaven.com/download/35321/Download.aspx

40. http://www.root.cz/clanky/linux-na-desktopu-roste-ale-uz-pomaleji/

41. Patton, R.: Testování softwaru, Computer Press, Praha 2002. 313 s.

42. http://basic.mindteq.com/index.php?i=podium [Získáno: 30. 1. 2013]

- 95 -