V první řadě se pochopitelně jedná o originální Atari BASIC, který byl součástí standardní ROM (8kB BASIC+16kB operační systém). V roce 1983 byl společností OSS (tu již dobře známe, vlastně na ni v oblasti vývojových nástrojů narážíme neustále) vydán dialekt BASICu pojmenovaný BASIC A+.

O další rok později vydala společnost OSS interpret programovacího jazyka BASIC, který byl pojmenován BASIC XL, a to podle toho, že běžel na systémech Atari XL (s plnou RAM) a pochopitelně taktéž na Atari XE. Opět se jednalo o poměrně významné vylepšení a rozšíření možností původního BASICu, k dispozici byly i metody k urychlení výsledných (interpretovaných) programů.

V roce 1985 společnost OSS vydala BASIC XE, a to z toho důvodu, že byl podporován přístup do rozšířené paměti počítačů Atari 130 XE (celkem neuvěřitelných 128 kB RAM) – program bylo možné oddělit do dat, přičemž program byl umístěn ve druhé bance RAM. BASIC XE nabízel i rychlejší matematické operace a oproti BASICu XL nabízel i několik dalších vylepšení (ovšem ne mnoho).

Dalším interpretrem programovacího jazyka BASIC je Atari Microsoft BASIC. Z několika pohledů se však jedná o dosti rozdílný interpret, než je tomu v (ideové) řadě Atari BASIC → BASIC A+ → BASIC XL → BASIC XE → Turbo BASIC. O rok později po vydání původního Atari Microsoft BASICu (1982) byla vydána jeho druhá verze s několika opravami a taktéž s několika novými příkazy..

Zapomenout nesmíme na slavný Turbo BASIC XL (či jen Turbo BASIC), jehož autorem je známý Frank Ostrowski (tento programátor později vytvořil GFA BASIC pro osobní počítače Atari ST). Turbo BASIC téměř splňoval všechny sny BASICových programátorů – byl rychlejší než původní Atari BASIC, byl s Atari BASICem plně kompatibilní, díky programovému „odklápění“ ROM nabízel vývojářům prakticky stejné nebo i větší množství volné operační paměti (což působilo téměř magicky) a navíc Turbo BASIC obsahoval poměrně velké množství nových příkazů, ať již určených pro strukturované programování (nové typy programových smyček), tak i příkazy zjednodušující programátorovu každodenní činnost.

Nejnovějším BASICem navrženým a implementovaným pro domácí osmibitové mikropočítače Atari je Fast BASIC, jehož popisem se budeme zabývat dnes. Jedná se projekt, který je v mnoha ohledech odlišný od klasických BASICů. V první řadě namísto překladu zdrojového kódu do sekvence tokenů používá překladač do bajtkódu. To je koncept, který známe například z Pythonu, programovacího jazyka Lua, Javy atd. (ale i z původního Pascalu). Při běhu programu (tedy v runtime) je bajtkód konvertován na instrukce mikroprocesoru (což si ukážeme). Výsledek je ovšem v každém případě rychlejší, než interpretace tokenizovaného kódu a většinou je bajtkód i kratší, než kód tokenizovaný.

Fast Basic se v několika ohledech odlišuje od většiny klasických interpretrů jazyka BASIC. Jedna změna je patrná na první pohled – zdrojové kódy programů nevyžadují zápis čísel řádků, což znamená, že programy psané ve Fast Basicu se spíše podobají skriptům psaným v jazyku Lua či Pythonu. To vede k nutnosti náhrady skoků realizovaných v klasických interpretrech BASICu příkazem GOTO za strukturované jazykové konstrukce – což znamená podmínky (rozvětvení) a různé varianty programových smyček (což je ostatně jen dobře a do značné míry to zamezuje vzniku „špagetového kódu“, kterým je BASIC nechvalně proslulý).

Druhá změna sice není na první pohled patrná, ale ovlivňuje způsob interpretace programů. Klasické BASICy prováděly tokenizaci zdrojového kódu na sekvenci tokenů ve stylu:

Poznámka: Atari BASIC sice nevyžaduje příkaz LET, ovšem v tokenizované podobě se zde nachází obdoba tokenu pro „implicitní LET“.

Ovšem interpretace takto reprezentovaného programu je velmi pomalá. Fast Basic je z tohoto důvodu postaven na bajtkódu. Sice se stále (při překladu) emituje sekvence tokenů, ovšem ty mají význam instrukcí bajtkódu: uložení proměnné na zásobník, provedení určité aritmetické operace, porovnání hodnoty s nulou atd. Navíc verze Fast Basicu pro PC obsahuje i optimalizaci bajtkódu – náhradu sekvence instrukcí bajtkódu za kratší či rychlejší variantu. Výsledek je (většinou) kratší a současně je interpretace rychlejší. Fast Basic tak může být pro stejné algoritmy zhruba 1,5× až 2× rychlejší než Turbo Basic XL (a ten je cca 3× až 5× rychlejší, než Atari Basic).

Mezi další vylepšení patří například podpora pro pole s osmibitovými a 16bitovými hodnotami, což je velmi praktické a pochopitelně to vede i k úsporám operační paměti. Taktéž je možné používat proměnné obsahující celá čísla a tím pádem obejít pomalé FP operace. Změnilo se i vývojové prostředí (pokud se využívá varianta Fast Basicu běžící přímo na Atari), protože se již nepoužívá klasický obrazovkový editor s čísly řádků, ale editor, který připomíná Vim – podporován je scrolling atd. (ostatně problematický či nepodporovaný scrolling popř. neexistence celoobrazovkového editoru je jedním z důvodů, proč byla čísla řádků vůbec do klasického BASICu původně zavedena).

Fast Basic existuje ve dvou variantách. První varianta je určena přímo pro provozování na osmibitových mikropočítačích Atari, což s sebou pochopitelně přináší určitá omezení. Této variantě se budeme věnovat později. Druhou variantu tvoří překladač, který je provozovatelný přímo na PC. To znamená, že vývoj (včetně editace a překladu) je prováděn na PC a výsledkem překladu jsou binární soubory ve formátu XEX popř. obrazy disket, které se spouští v emulátoru počítačů Atari popř. se ukládají na paměťová média používaná v reálných Atari. Obě varianty Fast Basicu lze získat z GitHub repositáře dostupného na adrese https://github.com/dmsc/fastbasic. Mimochodem: v tomto repositáři se nachází i zdrojové kódy assembleru ca65 a linkeru ld65. Nejedná se o náhodu, protože tyto dva nástroje jsou použity ve fázi překladu – i tu si pochopitelně popíšeme v navazujících kapitolách.

Ukažme si nyní praktické použití překladače Fast Basicu. Překládat budeme klasický program typu „Hello, world!“, který ve variantě pro Fast Basic vypadá následovně:

Poznámka: povšimněte si, že nejsou použita čísla řádků a příkazy není nutné psát velkými písmeny. A jak je v BASICu zvykem – nikde se nezapisují středníky ani další „divné paznaky“.

Výsledkem je soubor nazvaný hello_1.xex, jehož velikost je pouze 443 bajtů! Ano, to není žádná chyba: celý program i se svým runtime nedosahuje ani velikosti půl kilobajtu:

Výsledný program hello_1.xex je možné spustit v emulátoru osmibitových mikropočítačů Atari. Korektně se vypíše zpráva „Hello, world!“, ovšem poté program buď začne vypisovat BOOT ERROR nebo se vrátí do DOSu (nebo dokonce do Self Testu):

Abychom zabránili návratu do DOSu (který nemusí být načten do paměti) nebo „pádu“ do Self Testu, ukončíme zdrojový kód programu nekonečnou smyčkou DO-LOOP (takže ho vlastně neukončíme – program z této smyčky pochopitelně nikdy nevyskočí):

Výsledek je již lepší (řízení se nevrátí do DOSu) a výsledný program je přitom prodloužen pouze o dva bajty!:

Poznámka: to je zajímavé, protože v assembleru zabírá nekonečná smyčka tři bajty. Buď se použije instrukce JMP nebo nějaká instrukce Bcc, ovšem předtím se musí nastavit či naopak vynulovat příslušný příznak (carry, zero či overflow).

Ukažme si celý postup na jednoduchém demonstračním příkladu, v němž se nejprve přiřadí hodnoty do dvou proměnných x a y, provede se součet těchto proměnných s uložením výsledku součtu do proměnné z a konečně se obsah proměnné z vypíše na obrazovku. Fast Basic nevyžaduje deklaraci proměnných, takže celý příklad může vypadat následovně:

V případě, že při překladu použijeme přepínač -c, provede se pouze první fáze překladu z Fast Basicu do assembleru, což nám umožňuje prozkoumat, jak vlastně tento kód vypadá:

Poznámka: povšimněte si, že se skutečně jedná o bajtkód (bajty s jednotlivými instrukcemi bajtkódu) a nikoli o sekvenci instrukcí určenou pro spuštění na mikroprocesoru MOS 6502. Po určitém tréninku je možné bajtkód poměrně dobře čitelný.

V další fázi překladu se může vytvořit i soubor s listingem vytvořený assemblerem ca65. Ten bude v našem konkrétním případě vypadat takto:

Poznámka: v tomto případě se bohužel nezobrazí konkrétní hodnoty jednotlivých instrukcí bajtkódu.

Podívejme se nyní na realizaci výpočtu faktoriálu. Tento výpočet jsme si již kdysi ukazovali ve variantě určené pro Atari BASIC:

Přepis do Turbo BASICu (ze kterého Fast Basic částečně vychází) využívajícího pojmenované procedury – klíčová slova PROC a ENDPROC:

Úprava výše uvedeného programu pro Fast Basic je přitom relativně snadná. V prví fázi postačuje odstranit čísla řádků:

Dále můžeme volání procedury factorial provést přes znak zavináče (a nikoli příkazem exec – i to je ovšem možné). Povšimněte si, že parametry se do procedury factorial předávají přes globální proměnnou – to je prostě BASIC:

Ze zobrazených výsledků je patrné, že výpočty probíhají se šestnáctibitovými hodnotami se znaménkem, což konkrétně při výpočtu faktoriálu znamená velmi rychlé přetečení. Samozřejmě můžeme zapsat program ve Fast Basicu, který bude provádět výpočty s hodnotami s plovoucí řádovou čárkou, což je sice pomalejší (ve skutečnosti mnohem pomalejší), ale výsledky již budou korektní. Úprava programu spočívá v tom, že za jméno proměnné fact přidáme znak procenta, což vlastně znamená určení typu této proměnné:

Nyní budou výsledky vypočteny sice mnohem (mnohem!) pomaleji, ale jsou alespoň korektní:

Ve Fast Basicu jsou dostupné základní příkazy pro práci s grafikou. Tyto příkazy jsou odvozeny od standardního Atari Basicu, takže si jen v krátkosti ukažme použití příkazů graphics, color, plot a drawto:

Po překladu a spuštění tohoto příklady by se měl na obrazovce objevit barevný kříž:

Navíc je dostupný i příkaz fillto. Ten odpovídá příkazu drawto, ovšem navíc vyplňuje plochu napravo od vykreslované úsečky až po fcolor. Příkaz fillto je odvozen od operace FILL implementované pro zařízení S: (viz nedávné články o SIO, v nichž jsme se touto operací zabývali). S určitými chybami můžeme tento příkaz použít pro vykreslení vlajky:

Jak je při pohledu na výsledek patrné, program by ještě potřeboval vylepšit v oblasti horního a dolního okraje:

Jako jeden z mála interpretrů jazyka BASIC pro osmibitové domácí mikropočítače Atari podporuje Fast Basic i práci se sprity (PMG – Player-Missile Graphics). To je užitečné, protože není nutné volat příkazy POKE s „magickými“ hodnotami. Podpora je sice poměrně minimalistická, ovšem pro některé účely může být dostačující.

V první řadě byl přidán příkaz PMGRAPHICS pro povolení a nastavení režimu zobrazení spritů. Existují tři možnosti: sprity nejsou zobrazeny, sprity jsou zobrazeny v 128řádkovém režimu a sprity jsou zobrazeny v režimu 256řádkovém. Dalším příkazem je PMHPOS, kterým se nastavuje horizontální pozice hráčů a střel na obrazovce. Barvy hráčů a střel se nastavují standardním příkazem SETCOLOR s prvním parametrem nastaveným na záporné hodnoty –4 až –1. A nesmíme zapomenout na funkci PMADR, která vrací adresu paměťového bloku pro zvoleného hráče nebo všechny střely. A to je vlastně vše – ostatní operace zajistí buď POKE nebo příkaz pro přesun bloku paměti MOVE.

Již několikrát jsme se pokusili zobrazit hráče číslo 0 s bitmapou reprezentující „ufona“ ze slavné hry Space Invaders. Varianta pro Fast Basicu je (možná až na blok s daty) velmi čitelná a snadno pochopitelná:

Rozšíření programu o horizontální i vertikální pohyb hráče s využitím joysticku je relativně snadné. Postačuje program doplnit o proměnné x a y, logiku pro úpravu hodnot těchto proměnných v závislosti na náklonu joysticku, realizovat horizontální posun zavoláním příkazu PHPOS a vertikální posun přesunem bloku paměti příkazem MOVE. Ovšem program je tak rychlý, že ho musíme zpomalit příkazem PAUSE, který ve své základní variantě počká 1/50 nebo 1/60 sekundy (už asi tušíte, že se zde pracuje se snímkovou frekvencí):

Poznámka: pravděpodobně sami přijdete na to, proč má bitmapa hráče nyní výšku deseti řádků a nikoli řádků osm a proč je horní i spodní řádek nulový.

Ovšem znalci (Atari) BASICu by se nezdržovali zápisem podmínek if-else. Namísto toho by využili faktu, že porovnání (jedním znakem =) vrací na základě výsledku porovnání hodnotu 1 nebo 0, se kterou lze ihned provádět výpočty. Posun hráče po obrazovce by se tedy mohl zkrátit na:

Fast Basic obsahuje některé konstrukce, které se přibližují klasickému strukturovanému programování. Konkrétně to znamená to, že jsou podporovány procedury (pojmenované podprogramy), strukturovaná konstrukce IF-ELSE-ENDIF a programové smyčky FOR-NEXT, DO-LOOP, WHILE-WEND a REPEAT-UNTIL. Použití těchto konstrukcí si ukážeme na několika demonstračních příkladech:

PC varianta překladače Fast Basicu obsahuje podporu pro různé optimalizace prováděné na úrovni bajtkódu. Tyto optimalizace pracují zhruba následovně: detekuje se určitá sekvence instrukcí bajtkódu a ta je následně nahrazena za jinou sekvencí instrukcí, nebo se původní instrukce dokonce smažou, pokud nemají vliv na výsledný program. Ve velké většině případů se tedy nejedná o žádné pokročilé globální optimalizace typu rozbalení smyček atd. (to mimochodem nemá na MOS 6502 žádný větší význam), ovšem každá vynechaná instrukce (popř. jednodušší instrukce) pochopitelně výsledný program dokáže zrychlit, a to mnohdy poměrně významným způsobem.

Poznámka: tyto optimalizace je možné zakázat přepínačem -n. To má jedinou výhodu – výsledný kód (bajtkód) bude v takovém případě naprosto totožný s bajtkódem, který je vygenerován Fast Basicem běžícím přímo na osmibitovém Atari (ten totiž peephole optimalizátor neobsahuje).

Abychom si udělali malou představu, jak jsou vlastně peephole optimalizace na úrovni bajtkódu realizovány, podívejme se na příklady. První příklad maže sekvenci instrukcí pro přičtení nuly:

Náhrada sekvence instrukcí, které zvyšují hodnotu proměnné o jedničku, za specializovanou instrukci INCVAR (jak asi tušíte, je realizován instrukcí kombinací ADC+INC):

Podobných optimalizací existuje několik desítek.

Již několikrát jsme se v tomto seriálu setkali s různými programovacími jazyky, ať již interpretry či překladači, určenými pro osmibitové domácí mikropočítače Atari. A (alespoň prozatím) je výsledek stále stejný – pro tvorbu nejefektivnějších programů je (pochopitelně) nejlepší assembler a v relativně těsném závěsu za ním se pohybuje původní překladač programovacího jazyka Action! Jedinou vážnější nevýhodou Actionu je fakt, že původní verze nepodporuje operace s hodnotami s plovoucí řádovou čárkou. Teoreticky by měly být minimálně stejně kvalitní i překladače programovacího jazyka C, ovšem v praxi tomu tak není. V oblasti interpretrů je nejlepší dnes popisovaný Fast Basic, těsně za ním pak Turbo Basic XL (verze NEzaložená na překladači). Ostatní interprety BASICů jsou buď mnohem pomalejší, nebo jim chybí některé důležité vlastnosti (podpora pro multimediální příkazy atd.).

Poznámka: ovšem ještě jsme si nevyzkoušeli jazyk, který byl v době osmibitových počítačů velmi populární. Jedná se o FORTH.

Všechny demonstrační příklady, s nimiž jsme se v předchozích článcích i v článku dnešním seznámili a které jsou určeny pro překlad s využitím assembleru ca65, jsou dostupné, jak je zvykem, na GitHubu. V tabulce níže jsou uvedeny odkazy na jednotlivé zdrojové kódy příkladů psané v assembleru i „listingy“ vygenerované samotným assemblerem, ze kterých je patrné, jakým způsobem se jednotlivé příklady přeložily do výsledného XEX souboru: