Obsah
1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari
2. Assemblery, interpretry a překladače
6. Vybrané vlastnosti Atari BASICu
8. Strukturované programování v Turbo-BASICu
9. Pomůcky při vývoji a ladění programů v Turbo-BASICu
11. Unikátní vlastnosti Atari Loga
12. Interlisp/65 (INTER-LISP/65)
14. Programovací jazyk Action!
15. Datové typy v jazyku Action!
16. Programové konstrukce v jazyku Action!
19. Repositář s demonstračními příklady
1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari
V dnešním článku se seznámíme s vybranými programovacími jazyky používanými na domácích osmibitových mikropočítačích Atari. S některými dále zmíněnými jazyky jsme se sice již na stránkách Roota setkali dříve, ovšem většinou pouze ve stručnosti a v odlišném kontextu. Popíšeme si jak některé assemblery (resp. přesněji řečeno jazyky symbolických adres – JSA – popř. jazyky symbolických instrukcí – JSI), tak i vybrané interpretované jazyky, mezi které patří například Atari BASIC, Turbo-BASIC XL, Atari LOGO či Interlisp/65. Nezapomeneme ovšem ani na překladače (mezi něž ve světě osmibitových Atari patří zejména jazyk Action!) a dokonce ani na ty programovací jazyky, které leží na pomezí mezi čistými interpretry na straně jedné a čistými překladači na straně druhé – jedná se především o programovací jazyk Forth, konkrétně o jeho variantu pojmenovanou FIG-Forth zmíněnou v sedmnácté kapitole. Příště se zmíníme o mnohem mladším jazyku, jenž se jmenuje FastBASIC. Tento jazyk se v několika zásadních ohledech od klasických BASICů odlišuje a využívá se dnes v některých programátorských soutěžích.
Obrázek 1: Tuto obrazovku zná každý Atarista. Jedná se o výchozí režim osmibitových mikropočítačů Atari ve chvíli, kdy není přítomna cartridge, nebyl spuštěn Self Test, není zapnut režim nahrávání z kazetového magnetofonu ani není připojena disketová jednotka. V tomto režimu může uživatel zadávat příkazy Atari BASICu, s nímž se ve stručnosti seznámíme v rámci páté kapitoly. Na rozdíl od implementací BASICu pro některé jiné mikropočítače je v případě Atari BASICu k dispozici celoobrazovkový textový editor s průběžnou kontrolou chyb.
Obrázek 2: Uvítací obrazovka jedné z variant Interlispu pro osmibitové domácí mikropočítače Atari. O tomto jazyku se zmíníme ve dvanácté kapitole.
2. Assemblery, interpretry a překladače
Na osmibitových mikropočítačích (a nyní se zaměříme především na domácí mikropočítače) měli ti uživatelé, kteří se chtěli zabývat programováním, na výběr z relativně velkého množství různých vývojových nástrojů a pomůcek. Některé mikropočítače byly vybaveny pouze velmi jednoduchým operačním systémem zajišťujícím základní vstupně/výstupní operace (čtení klávesnice, zápis znaku na obrazovku, rutiny pro čtení a zápis dat na magnetofon). Poměrně často byl tento minimalistický operační systém doplněn o takzvaný monitor což byl (a někde doposud je) program umožňující manipulaci s daty v operační paměti, tj. zápis dat do paměti, čtení (zobrazení) vybraného bloku, přesun bloku, vyplnění určité oblasti konstantou, čtení a zápis dat na externí paměťové médium (typicky na magnetofon) a některé pokročilejší monitory byly vybaveny i takzvaným disassemblerem umožňujícím transformaci sekvence bajtů na symbolické instrukce. Mimochodem – při výpisu obsahu operační paměti se v monitorech většinou používal stejný formát, jaký najdeme u mnoha moderních programátorských hexa editorů.
Obrázek 3: Celoobrazovkové uživatelské rozhraní monitoru pro mikropočítače Apple II.
Obrázek 4: Monitor pro slavné osmibitové počítače Commodore C64.
Monitory, zejména ty vybavené disassemblerem (zpětným assemblerem) bylo možné použít i pro tvorbu programů na úrovni strojového kódu. Program se většinou nejprve zapsal na papír ve formě assembleru, dále se provedl ruční překlad jednotlivých instrukcí do sekvence decimálních nebo hexadecimálních číslic a následně se tato sekvence zapsala do monitoru do určité předem vybrané oblasti operační paměti. V případě, že monitor podporoval zápis bloku paměti na externí paměťové médium (kazetový magnetofon, disketu), jednalo se o dosti primitivní, ovšem stále ještě použitelné (a v některých případech i používané) vývojové prostředí. Programování na úrovni strojového kódu je samozřejmě velmi pracné, zejména ve chvíli, kdy je nutné existující program modifikovat a tím pádem měnit cílové adresy skoků, adresy globálních proměnných atd. Mnohem civilizovanější způsob představovalo použití takzvaných assemblerů, což byly nástroje schopné překládat programy zapsané v jazyku symbolických adres/instrukcí do strojového kódu – ostatně přesně pro podobné činnosti jsou počítače zkonstruovány.
Obrázek 5: Jedním z poměrně velkého množství assemblerů vyvinutých pro osmibitové mikropočítače Atari je SynAssembler vytvořený a prodávaný společností Synapse Software. Tato společnost, s níž jsme se již na stránkách Roota seznámili, se nezaměřovala pouze na vývoj počítačových her. Kromě nich totiž vydávala i programy určené jak pro běžné koncové uživatele (FileManager 800, DiskManager, SynFile+, SynCalc, SynChron, SynComm, SynStock, SynTrend, …) tak právě vývojové nástroje; mezi nimi i SynAssembler.
Na osmibitových domácích mikropočítačích se používaly dva typy assemblerů. Prvním typem byly assemblery interaktivní, které uživateli nabízely poměrně komfortní vývojové prostředí, v němž bylo možné zapisovat jednotlivé instrukce, spouštět programy, krokovat je, vypisovat obsahy registrů mikroprocesoru atd. Výhodou takto pojatého řešení byla nezávislost těchto assemblerů na rychlém externím paměťovém médiu. S těmito assemblery určenými pro počítače Atari se ve stručnosti seznámíme i v dnešním článku, protože jak Atari Assembler Editor, tak i MAC/65 náleží do této kategorie. Druhý typ assemblerů je používán dodnes – jedná se vlastně o běžné překladače, kterým se na vstupu předloží zdrojový kód (uložený na kazetě či disketě) a po překladu se výsledný nativní kód taktéž uloží na paměťové médium (odkud ho lze spustit). Tyto assemblery byly mnohdy vybaveny více či méně dokonalým systémem maker (odtud název macroassembler). Příkladem takového assembleru pro Atari jsou všechny moderní crossassemblery.
Obrázek 6: Disassembler (zpětný assembler) určený pro mikropočítače Atari (úvodní nastavení).
Mezi nejpoužívanější jazyky populární v dobách osmibitových domácích mikropočítačů patřily zejména výše zmíněné assemblery a taktéž více či méně dokonalé interpretry BASICu. To ovšem neznamená, že by nabídka programovacích jazyků byla takto omezená. Ve skutečnosti bylo na osmibitové mikropočítače portováno velké množství překladačů vyšších programovacích jazyků, zejména jazyků podporujících procedurální paradigma, tj. skládání programů z procedur (subrutin), v nichž se používají strukturované konstrukce pro tvorbu rozeskoků a programových smyček.
Obrázek 7: Disassembler určený pro mikropočítače Atari (výpis disassemblovaného kódu).
Z těchto jazyků byl populární především Pascal, a to díky tomu, že tento jazyk byl navržen takovým způsobem, aby byl překlad programů proveden jednoprůchodově a tudíž velmi rychle v porovnání s víceprůchodovými překladači. Ovšem existovaly i další jazyky, například i populární céčko. Zde je nutné zmínit především známý překladač Aztec C portovaný na velké množství různých typů mikropočítačů, zapomenout nesmíme ani na Deep Blue C pro počítače Atari (zde se autoři museli vyrovnat s faktem, že znaková sada neobsahovala složené závorky, tento jazyk měl ovšem i mnoho dalších omezení). A taktéž se jednalo o jazyky, které vznikly pouze pro jedinou platformu a jinam se nerozšířily. Ve světě osmibitových Atari je takovým jazykem Action!.
3. Atari Assembler Editor
Jedním z nejstarších vývojových nástrojů pro osmibitové mikropočítače Atari je Atari Assembler Editor, jehož vznik se datuje do let 1979 až 1980. Tento nástroj byl používán i pro vývoj samotného operačního systému počítačů Atari. Jak však tento nástroj vůbec vznikl, když ještě vlastně počítače Atari nebyly dokončené? První (zjednodušené) verze byly ručně děrovány na děrnou pásku, která byla použita pro naprogramování čipu EPROM. Ten byl vložen do prototypu Atari a následně otestován. Jednalo se tak o jednu z forem bootstrapingu, kterým jsme ze zabývali v článku Můžeme věřit překladačům? Projekty řešící schéma „důvěřivé důvěry“. Výsledná podoba Atari Assembler Editoru byla dodávána na standardní cartridge o kapacitě osmi kilobajtů (ovšem ve skutečnosti se do značné míry využívaly subrutiny z operačního systému a používané i Atari Basicem).
Obrázek 8: Úvodní obrazovka Atari Assembler Editoru je pojata přísně minimalisticky. Pouze se na ní oznamuje aktuálně vybraný režim, zde konkrétně režim editace.
Atari Assembler Editor se skládal ze tří částí: editoru, assembleru a debuggeru (což však byl ve skutečnosti pouze monitor). Všechny tři části byly dostupné z cartridge a bylo možné se mezi nimi přepínat. Zdrojový kód zapisovaný v editoru byl překládán dvouprůchodovým překladačem a mohl být v operační paměti uložen souběžně se zdrojovým kódem, což ovšem znamenalo omezení maximálního objemu zdrojového kódu. Zajímavé a typické pro interaktivní assemblery je, že řádky zdrojového kódu byly číslovány, podobně jako v BASICu. K dispozici však byly i poměrně pokročilé operace pro vyhledání návěští atd.
Obrázek 9: Přepnutí do režimu debuggeru a výpis obsahu prvních několika bajtů s interpretrem jazyka Basic.
Debugger (spíše monitor) umožňoval zobrazení obsahu operační paměti, zobrazení obsahu registrů mikroprocesoru, modifikaci paměti, zobrazení disassemblované části paměti, krokování programu atd. – ovšem ne tak kvalitně, jako tomu bylo u dále popsaného assembleru MAC/65.
Obrázek 10: Disassembling neboli zobrazení symbolických instrukcí získaných z obsahu strojového kódu.
4. MAC/65
Další programátorský nástroj, s nímž se dnes alespoň ve stručnosti seznámíme, se jmenuje MAC/65. Jedná se o assembler a současně i o debugger, jehož ovládání je odvozeno od výše zmíněného Atari Assembler Editoru; ve skutečnosti je však MAC/65 prakticky po všech stránkách lepší (až na poněkud vyšší cenu). Za vývojem MAC/65 stála společnost Optimized Systems Software (OSS), s níž se setkáme ještě jednou v souvislosti s programovacím jazykem Action! (ovšem OSS vytvořila i překladače jazyků C a Pascalu). MAC/65 byl dodáván na specializované cartridgi s kapacitou 16kB, což je dvojnásobná kapacita, než jakou počítače Atari podporují (konektor měl pouze třináct adresních pinů). Z tohoto důvodu bylo oněch 16kB rozděleno do dvojice paměťových bank, z nichž každá měla kapacitu osmi kilobajtů a mezi kterými se provádělo automatické přepínání (taková cartridge se někdy nazývala „supercartridge“ a existovalo jich více typů, které se lišily způsobem přepínání paměťových bank).
Obrázek 11: Úvodní obrazovka MAC/65 verze 1.02.
Předností assembleru MAC/65 byl mnohem rychlejší překlad v porovnání s Atari Assembler Editorem. Taktéž byla k dispozici lepší forma debuggeru dostupná pod příkazem DDT. Některé základní vlastnosti MAC/65 si ukážeme na sérii screenshotů, v němž vytvoříme velmi jednoduchou programovou smyčku.
Obrázek 12: V režimu EDIT se zapisují jednotlivé deklarace i instrukce procesoru MOS 6502. Řádky s deklaracemi a instrukcemi jsou číslovány, takže přidání, resp. smazání řádku je snadné. Taktéž je možné si vyžádat automatické číslování (což například Atari BASIC neumí). K dispozici jsou i složitější příkazy – obecně je možné říci, že programátorský editor v MAC/65 je propracovanější, než v případě BASICů.
Obrázek 13: Po žádosti o překlad se zobrazí (pokud to ovšem není zakázáno příslušnou deklarací) zapsaný program i s ukázkou strojového kódu. V prvním sloupci jsou adresy, v dalším sloupci pak vlastní strojový kód (operační kódy instrukcí).
Obrázek 14: Příkazem DDT se spustí debugger a současně i monitor. Můžeme zde vidět, že se zobrazuje jak obsah paměti (s instrukcemi strojového kódu), tak i registry mikroprocesoru, obsah příznakového registru a nastavené breakpointy.
Obrázek 15: Do vstupního pole ENTER COMMAND se zapisují příkazy debuggeru.
Obrázek 16: Po opuštění debuggeru příkazem Q je možné pokračovat ve vývoji, například si nechat vypsat uživatelem zapsaný kód příkazem PRINT, zde bez čísel řádků.
5. Atari BASIC
Popis vývojových nástrojů a programovacích jazyků pro osmibitové mikropočítače Atari by samozřejmě nebyl úplný, pokud by nebyl zmíněn vyšší programovací jazyk, jehož více či méně kvalitní dialekty existovaly prakticky pro všechny typy domácích (ale i profesionálních) osmibitových počítačů. Jedná se samozřejmě o jazyk BASIC (Beginner's All-purpose Symbolic Instruction Code), jehož syntaxe a především sémantika pozitivně ale i negativně ovlivnily celou jednu generaci programátorů (včetně autora tohoto článku :-). Ovšem tento programovací jazyk je z historického hlediska zajímavý i proto, že se v souvislosti s jeho vývojem poprvé objevují jména Bill Gates a Paul Allen spolu s jejich společností původně nazývanou Micro-Soft.
Obrázek 17: Programovací jazyk Atari BASIC obsahoval příkazy, pomocí nichž bylo možné nastavovat různé grafické režimy, vykreslovat body (pixely) či úsečky, popř. měnit barvovou paletu. Na tomto obrázku je zobrazen grafický režim číslo 15, v němž se zobrazuje čtyřbarevná bitmapa o rozlišení 160×160 pixelů, pod níž jsou umístěny čtyři textové řádky, které může interpret jazyka BASIC využít stejným způsobem, jako standardní textový režim (číslo 0) – tedy pro svůj interaktivní editor.
Osmibitové mikropočítače Atari byly dodávány s 24 kB paměti ROM, přičemž 16 kB obsadil samotný operační systém počítače (včetně ovladačů základních periferních zařízení) a zbylých 8 kB bylo vyhrazeno pro interpret programovacího jazyka BASIC. Inženýři ze společnosti Atari původně plánovali využít, podobně jako například firma Apple pro její modely Apple ][, programovací jazyk BASIC dodaný firmou Micro-Soft, ovšem tento interpret se nevešel do zbylých 8 kB paměti ROM (někteří lidé poněkud zlomyslně poznamenávají, že Micro-Soft měl již tehdy problém s hardwarovou náročností svých aplikací, což se projevilo právě při portaci interpretru BASICu na procesor MOS 6502, při jehož programování je nutná poměrně podrobná znalost jeho adresových režimů).
Obrázek 18: Ukázka použití grafického režimu číslo 8, v němž se pracovalo s monochromatickou bitmapou o rozlišení 320×160 pixelů a obligátním čtyřřádkovým textovým polem.
Vzhledem k tomu, že rozšíření kapacity paměti ROM by bylo problematické a samozřejmě i poměrně drahé (každý ušetřený dolar se v tomto případě násobil počtem prodaných počítačů) se nakonec firma Atari rozhodla, že bude financovat vývoj vlastního interpretru programovacího jazyka BASIC, přičemž na nový jazyk měla dva základní požadavky – interpret se musí vejít do 8 kB ROM a jazyk by měl obsahovat příkazy, které by alespoň částečně dokázaly využít grafické a zvukové schopnosti počítačů Atari, což je důležité jak z praktického, tak i obchodního hlediska. Atari BASIC, jak se nově vzniklý programovací jazyk jmenoval, se skutečně podařilo uložit do pouhých osmi kilobajtů paměti ROM. Jednalo se sice o relativně pomalý interpret, ovšem jeho vlastnosti byly poměrně zajímavé. Tento dialekt BASICu totiž obsahoval celou řadu rutin umožňujících práci s rozličnými grafickými režimy čipů ANTIC a GTIA; například se jednalo o příkazy COLOR, SETCOLOR, PLOT, DRAWTO, POSITION či LOCATE.
Obrázek 19: Jednoduchý program pro výpočet největšího společného dělitele (NSD, GCD) celých čísel z řady 2..10. V tomto programu jsou mj. využity i některé formátovací možnosti příkazu PRINT, například přechod na další tabulační zarážku (formátovací znak čárka) či zákaz přechodu na další řádek (formátovací znak středník).
Dále Atari BASIC obsahoval příkaz SOUND pro základní ovládání zvukového čipu POKEY (POKEY byl při práci v Atari BASICu nastaven do režimu čtyřkanálového zvukového generátoru, kde byl každému kanálu přiřazen jeden osmibitový čítač). Tento programovací jazyk dále umožňoval práci se skalárními proměnnými, jednorozměrnými poli (vektory) i dvourozměrnými poli (maticemi), v nichž mohla být uložena čísla s pohyblivou řádovou čárkou. Každé číslo bylo reprezentováno šesticí bajtů, jejich rozsah i přesnost tedy ležely zhruba v polovině mezi typy single a double známými z dnešních programovacích jazyků a matematických koprocesorů. Taktéž bylo možné pracovat s jednorozměrnými řetězci (pole řetězců však nebyla přímo v jazyku podporována, většinou se nahrazovala jediným řetězcem a vektorem indexů nebo oddělovacími znaky).
Obrázek 20: Hra naprogramovaná v Atari BASICu s využitím strojových subrutin (Dungeons of Xotha).
Jednou z nevýhod Atari BASICu byla jeho pomalá interpretace a taktéž to, že dokázal pracovat pouze s šestibajtovými reálnými čísly, nikoli například s dvoubajtovými čísly celými, jak tomu bylo v některých jiných dialektech BASICu. Právě kvůli pomalým rutinám pro práci s reálnými čísly (resp. přesněji řečeno s čísly s plovoucí řádovou čárkou) a pomalém vyhledávání cílů skoků se jednalo o jeden z pomalejších interpretrů, zejména při porovnání s konkurenčními platformami.
Obrázek 21: Další screenshot ze hry Dungeons of Xotha.
6. Vybrané vlastnosti Atari BASICu
V Atari BASICu, přesněji řečeno v subrutinách uložených v ROM, které se staraly o výpočty nad reálnými čísly, se používal formát odlišný od prakticky všech formátů používaných na jiných platformách. Stále se sice jednalo o hodnoty s plovoucí řádovou čárkou, ovšem báze nebyla rovna dvěma (většina strojů) ani šestnácti (IBM/360), ale stu! Navíc nebyla mantisa uložená binárně, ale používal se kód BCD, což konkrétně znamená, že v pěti bajtech bylo uloženo přesně deset číslic (procesor 6502 dokázal s BCD pracovat nativně). To na jednu stranu není úplně špatné řešení, protože ho najdeme například na mnoha kalkulačkách. Zjednodušují se převody řetězců na čísla a naopak, na druhou stranu jsou však veškeré výpočty značně pomalejší a přesnost ani rozsah hodnot není tak vysoký, jako při použití binárního kódu. I z tohoto důvodu další dialekty BASICu zaváděly práci s celými čísly.
Příklad výpočtu založeného na práci s reálnými čísly počítačů Atari ukazuje, že i proměnné používané v programových smyčkách FOR-NEXT byly reprezentovány jako reálné číslo:
1 REM VYPOCET KONSTANTY PI 2 REM UPRAVA PRO ATARI BASIC 3 REM 10 N=1 20 FOR I=1 TO 10 25 GOSUB 1000:REM VYPOCET PI 30 PRINT I,N,PI 35 N=N*2 40 NEXT I 999 END 1000 REM 1001 REM SUBRUTINA PRO VYPOCET PI 1002 REM 1010 PI=4 1020 FOR J=3 TO N+2 STEP 2 1030 PI=PI*(J-1)/J*(J+1)/J 1040 NEXT J 1050 RETURN
Zajímavým způsobem je v Atari BASICu realizováno uložení řetězců, což je vedle jednorozměrných a dvourozměrných polí jediná datová struktura (na rozdíl od jediného primitivního typu – čísel s plovoucí řádovou tečkou). V tomto dialektu BASICu je totiž nutné velikost řetězce předem určit příkazem DIM, který současně i provede alokaci bloku v operační paměti pro řetězec. Ve skutečnosti jsou však v operační paměti uloženy dvě struktury, které řetězec plně popisují – jedná se především o sekvenci znaků v kódování ATASCII (odvozeno od ASCII doplněním spodních 32 znaků a změnou několika běžných znaků) a taktéž o strukturu o délce osmi bajtů, která obsahuje typ proměnné (první bajt), index jména proměnné s řetězcem (druhý bajt), adresu začátku řetězce (přesněji řečeno offset), alokovanou délku řetězce (maximálně 32767 znaků) a aktuální délku řetězce (opět maximálně 32767 znaků). To znamená, že i když je například provedena alokace pro řetězec o délce 1000 znaků, může v něm být reálně uloženo jen deset znaků.
Obrázek 22: Po inicializaci interpretru Atari Basicu je k dispozici 37902 volných bajtů. Po alokaci řetězce o délce deseti znaků přijdeme celkem o 20 bajtů – dva bajty zabere název proměnné, osm bajtů struktura popsaná v předchozím odstavci (typ+index proměnné, adresa řetězce, jeho maximální délka a aktuální délka) a zbylých 10 bajtů je vyhrazeno pro vlastní řetězec.
Veškeré operace s řetězci jsou zcela bezpečné, protože nikdy nedojde k překročení jeho délky (přepisu jiné paměti); při spojování řetězců dojde k ukončení na předem stanoveném limitu. Mimochodem: poměrně častým trikem bylo uložení strojových instrukcí do řetězce, zjištění adresy řetězce funkcí ADR a „spuštění řetězce“ další funkcí USR, které se předala adresa řetězce (resp. jeho prvního znaku).
Obrázek 23: Pokud alokujeme další řetězec o maximální kapacitě 100 znaků, přijdeme o 110 bajtů. Opět platí, že „chybějících“ deset bajtů bylo použito pro jméno proměnné, její typ, adresu+délku+maximální délku řetězce.
Vzhledem k tomu, že Atari BASIC neumožňuje ukládat řetězce do polí, bylo možné operátor indexování () „přetížit“ takovým způsobem, že je možné přistupovat jak k jednotlivým znakům řetězce, tak i k podřetězci (jedná se tedy o operaci, kterou dnes nazýváme termínem slicing). Tento operátor je možné použít i na levé straně přiřazovacího příkazu pro změnu vybrané části řetězce, což je velmi užitečný přístup k řetězcům:
10 DIM S$(15),T$(15),Q$(15) vypíše se 20 S$="ATASIC":PRINT S$ ATASIC 30 Q$=S$(3,5):PRINT Q$ ASI 40 T$="RI_BA":PRINT T$ RI_BA 50 S$(7,13)="T$:PRINT S$ ATASICRI_BA 60 S$=S$(1,6):PRINT S$ ATASIC 70 T$(6,9)=S$(4,6):PRINT T$ RI_BASIC 80 S$(4)=T$:PRINT S$ ATARI_BASIC 90 Q$=S$(1):PRINT Q$ ATARI_BASIC 100 Q$=S$(1,1):PRINT Q$ A
Obrázek 24: Z výpisu adres řetězců je zřejmé, že jsou v paměti uloženy těsně za sebou (první řetězec má délku 10 znaků) a že se nepočítá s žádným ukončovacím znakem.
Obrázek 25: Do řetězce A$ o kapacitě deseti znaků můžeme uložit kratší text a zjistit jeho délku. Při snaze o uložení delšího textu nedojde k žádné chybě a už vůbec ne k přepisu cizí paměti – řetězec se pouze na příslušném místě odřízne.
Obrázek 26: Pokus o alokaci řetězce, který se již nevejde do volné operační paměti samozřejmě skončí s chybou a proměnná nebude vytvořena.
Podívejme se nyní na způsob uložení programového kódu v operační paměti. Ihned po zápisu každého řádku se provádí takzvaná tokenizace, která nahradí jednotlivé konstrukce jazyka osmibitovými kódy. Příkladem může být tokenizace tohoto programového řádku:
10 LET X=1 : PRINT X
V operační paměti tento kód není uložen (pouze v bufferu textového editoru, odtud je však ihned poté přemazán). Namísto toho se uloží sekvence bajtů s následujícím významem:
číslo programového řádku (10)| Sekvence bajtů | Stručný popis |
|---|---|
| A0 00 | |
| 13 | délka celého tokenizovaného řádku (19 bajtů) |
| 0F | offset konce prvního příkazu |
| 06 | token příkazu LET |
| 80 | index proměnné X |
| 2D | token operátoru = |
| 0E | následuje numerická konstanta |
| 40 01 00 00 00 00 | takto vypadá zakódovaná hodnota 1 (na začátku je exponent) |
| 14 | konec (prvního) příkazu |
| 13 | offset konce druhého příkazu |
| 20 | token příkazu PRINT |
| 80 | index proměnné X |
| 16 | značka EOL pro konec řádku |
Před začátkem tokenizovaného kódu se ještě ukládá několik tabulek, především tabulka s proměnnými, tabulka s vektory (adresami) několika dalších paměťových struktur atd. Například následující zdrojový kód:
10 PRINT "X="; 20 INPUT X 30 PRINT "Y="; 40 INPUT Y 50 IF X=Y THEN PRINT "GCD: ";X:END 60 IF X>Y THEN X=X-Y:GOTO 50 70 IF X<Y THEN Y=Y-X:GOTO 50
Se převede do tokenizované a spustitelné (resp. interpretovatelné) podoby takto:
00000000: 00 00 00 01 02 01 03 01 13 01 85 01 96 01 d8 d9 ................ 00000010: 00 00 00 40 08 00 00 00 00 00 01 40 08 00 00 00 ...@.......@.... 00000020: 00 0a 00 0b 0b 20 0f 02 58 3d 15 16 14 00 07 07 ..... ..X=...... 00000030: 02 80 16 1e 00 0b 0b 20 0f 02 59 3d 15 16 28 00 ....... ..Y=..(. 00000040: 07 07 02 81 16 32 00 18 09 07 80 22 81 1b 15 20 .....2....."... 00000050: 0f 05 47 43 44 3a 20 15 80 14 18 15 16 3c 00 1b ..GCD: ......<.. 00000060: 09 07 80 21 81 1b 11 36 80 2d 80 26 81 14 1b 0a ...!...6.-.&.... 00000070: 0e 40 50 00 00 00 00 16 46 00 1b 09 07 80 20 81 .@P.....F..... . 00000080: 1b 11 36 81 2d 81 26 80 14 1b 0a 0e 40 50 00 00 ..6.-.&.....@P.. 00000090: 00 00 16 00 80 11 11 19 0f 09 48 3a 47 43 44 2e ..........H:GCD. 000000a0: 42 49 4e 16 BIN.
Velikost souboru s čitelným zdrojovým programem v BASICu je rovna 146 bajtům, zatímco soubor s tokenizovanou formou má v tomto případě délku 164 bajtů.
Obrázek 27: Jednou z her naprogramovaných v Atari BASICu je simulátor jaderné elektrárny SCRAM. Viz též Historie vývoje počítačových her: simulace a strategické hry naprogramované Chrisem Crawfordem
7. Slavný Turbo-BASIC XL
Rychlost interpretru programovacího jazyka Atari BASIC záhy přestala mnoha programátorům a samozřejmě i uživatelům dostačovat. Někteří z vývojářů se namísto BASICu naučili využívat assembler mikroprocesoru MOS 6502, ovšem jiní by uvítali „pouze“ rychlejší variantu BASICu, ideálně ještě doplněnou o některé chybějící příkazy. Kromě poměrně neúspěšného Microsoft BASICu se záhy rozšířil překladač BASICu do strojového kódu (který byl ovšem v praxi použitelný především pro překlad již odladěných programů, nikoli pro samotný vývoj) a především 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.
Obrázek 28: Úvodní obrazovka Turbo-BASICu XL.
Obrázek 29: Program pro vykreslení Mandelbrotovy množiny naprogramovaný v Atari BASICu, ovšem beze změn použitelný i v Turbo BASICu.
Novými „grafickými“ příkazy byly například CIRCLE či TEXT (vykreslení textu do bitmapy), k příkazu SOUND přibyl příkaz DSOUND (práce se šestnáctibitovými čítači čipu POKEY namísto čítačů osmibitových), dvojice příkazů POKE a PEEK pracujících s hodnotami uloženými v jedné (osmibitové) paměťové buňce byla doplněna o šestnáctibitové varianty DPOKE a DPEEK, což programátorům ušetřilo opakované použití výrazů typu PEEK(88)+256*PEEK(89) atd. Originální Turbo BASIC byl různým způsobem upravován a rozšiřován. Mezi tuzemské úpravy patří především zabudování ovladače Turba 2000, takže se práce s kazetovým magnetofonem v mnohém vylepšila (LOAD „T:POKUS.BAS“ namísto primitivního CLOAD atd.) a taktéž zabudování ovladače tiskárny BT-100 – kromě nové funkce příkazů LLIST, LPRINT atd. bylo dokonce možné vyvolat hardcopy obrazovky, tj. tisk aktuálního obsahu obrazovky a to i tehdy, pokud byl použit nějaký nestandardní grafický režim.
Obrázek 30: Výsledek běhu programu, jehož listing je zobrazený na patnáctém obrázku. Doba výpočtu Mandelbrotovy množiny dosahuje několika hodin v případě použití Atari BASICu a cca jednu hodinu při použití Turbo BASICu.
Turbo BASIC převzal z Atari BASICu i mnohé nedokonalosti. Jedna z nich se týká automatického rozpoznávání příkazů – klasické BASICy totiž vždy musely za číslem řádku používat příkaz, což například znamenalo, že přiřazení muselo začínat slovem LET. Atari BASIC již explicitní LET nevyžaduje (přidává si totiž vlastní LET s odlišným tokenem), ovšem v případě, že jméno proměnné začíná stejně jako příkaz, nebude tento koncept pracovat korektně.
Podívejme se na následující příklad, kde se snažíme přiřadit hodnoty do dvou proměnných nazvaných ED a PRINTED:
1 REM JMENO PROMENNE ZACINAJICI NA PRINT 2 REM UPRAVA PRO ATARI BASIC 3 REM 10 ED=42 20 PRINTED=0 30 PRINTED=42
Atari BASIC ovšem tento program pochopí jinak – jako snahu o výpis, zda je hodnota proměnné ED rovna nule či 42:
1 REM JMENO PROMENNE ZACINAJICI NA PRINT 2 REM UPRAVA PRO ATARI BASIC 3 REM 10 ED=42 20 PRINT ED=0 30 PRINT ED=42
V Turbo BASICu je problém ještě větší, protože tento jazyk obsahuje více klíčových slov. Další příklad je tedy zcela korektní v Atari BASICu, ovšem nikoli v Turbo BASICu, protože DO je v tomto jazyce klíčové slovo:
1 REM JMENO PROMENNE ZACINAJICI NA DO 2 REM UPRAVA PRO TURBO BASIC 3 REM 10 DONE=1 20 DONE=0
8. Strukturované programování v Turbo-BASICu
Turbo-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. Interpret Turbo BASICu dokáže tyto konstrukce automaticky vypsat s odsazením, které v tokenizovaném kódu nezabírá žádné místo (tudíž zde neexistují nekonečné diskuse o tom, jak má odsazení vypadat, o kolik znaků se odsazuje a zda používat TAB nebo mezery). Použití těchto konstrukcí si ukážeme na několika demonstračních příkladech.
Výpočet faktoriálu v Atari BASICu, v němž se podprogramy realizují pomocí GOSUB a RETURN:
1 REM VYPOCET FAKTORIALU 2 REM UPRAVA PRO ATARI BASIC 3 REM 10 FOR N=0 TO 20 11 GOSUB 100 12 PRINT N,FACT 13 NEXT N 99 END 100 REM VYPOCET FAKTORIALU 101 FACT=1 102 FOR I=N TO 1 STEP -1 103 FACT=FACT*I 104 NEXT I 105 RETURN
Přepis do Turbo BASICu využívajícího pojmenované procedury – klíčová slova PROC a ENDPROC:
1 REM VYPOCET FAKTORIALU 2 REM UPRAVA PRO TURBO-BASIC XL 3 REM 4 ------------------------------ 10 FOR N=0 TO 20 11 EXEC FACTORIAL 12 PRINT N,FACT 13 NEXT N 99 END 100 ------------------------------ 101 REM VYPOCET FAKTORIALU 102 PROC FACTORIAL 103 FACT=1 104 FOR I=N TO 1 STEP -1 105 FACT=FACT*I 106 NEXT I 107 ENDPROC
Výpočet největšího společného dělitele s několika příkazy GOTO:
1 REM VYPOCET NEJVETSIHO SPOLECNEHO DELITELE 2 REM REALIZACE V ATARI BASICU 3 REM 10 PRINT "X="; 20 INPUT X 30 PRINT "Y="; 40 INPUT Y 50 IF X=Y THEN PRINT "GCD: ";X:END 60 IF X>Y THEN X=X-Y:GOTO 50 70 IF X<Y THEN Y=Y-X:GOTO 50
Realizace s využitím WHILE-WEND a strukturovaných podmínek:
1 REM VYPOCET NEJVETSIHO SPOLECNEHO DELITELE 2 REM IMPLEMENTACE PRO TURBO-BASIC XL 3 REM 4 ------------------------------ 10 PRINT "X="; 20 INPUT X 30 PRINT "Y="; 40 INPUT Y 50 WHILE X<>Y 60 IF X>Y 61 X=X-Y 63 ENDIF 70 IF X<Y 71 Y=Y-X 73 ENDIF 80 WEND 90 PRINT "GCD: ";X 91 END
Využití programové smyčky typu REPEAT-UNTIL s podmínkou na konci:
1 REM TEST PRESNOSTI VYPOCTU FP 2 REM REALIZACE PRO TURBO-BASIC XL 3 REM 4 ------------------------------ 10 H1=0 11 H2=0 12 N=1 20 REPEAT 21 H1=H2 22 H2=H1+1/N 23 PRINT N;" ";H1;" ";H2 24 N=N+1 30 UNTIL H1=H2
Využití programové smyčky typu REPEAT-UNTIL s podmínkou na konci i klasické smyčky FOR-NEXT:
1 REM CIRCLE MOIRE 2 REM UPRAVA PRO ATARI BASIC 3 REM GRAFICKY REZIM 9 4 ------------------------------ 10 GRAPHICS 9 20 FOR Y=0 TO 191 30 FOR X=0 TO 79 40 C=INT(X*X/10+Y*Y/40) 50 COLOR C MOD 16 60 PLOT X,Y 70 NEXT X 80 NEXT Y 998 REM CEKANI NA STISK TLACITKA JOYSTICKU 999 REPEAT :UNTIL STRIG(0)=0 1000 END
9. Pomůcky při vývoji a ladění programů v Turbo-BASICu
Při ladění programů v Turbo-BASICu lze využít několik užitečných příkazů. Především se jedná o příkaz TRACE, jenž po spuštění programu začne vypisovat čísla řádků, které se právě spouští. Dále musíme zmínit příkaz DUMP určený pro výpis všech proměnných, samozřejmě včetně jejich hodnoty. Výpis lze provést i na vybrané zařízení, například na tiskárnu, disketovou jednotku, RAMdisk atd. S čísly řádků tak typickými právě pro klasické BASICy souvisí i příkazy pro jejich manipulaci. Jedná se o příkaz DEL pro smazání vybraných řádků, resp. rozsahu hodnot a dále o příkaz RENUM pro přečíslování určitého bloku. Pro získání informace o poslední chybě (tu lze odchytit pomocí TRAP) slouží pseudoproměnné ERR (číslo chyby) a ERL (číslo programového řádku). A konečně – při vzniku chyby se nevypíše pouze její číslo (kód), ale i krátký popisek chyby.
10. Atari LOGO
Většina programovacích jazyků byla vytvořena buď pro potřeby praktického programování nebo pro výuku programování. Programovací jazyk Logo, o němž se v dnešním článku taktéž v krátkosti zmíníme, je v tomto smyslu poněkud odlišný jazyk, protože programování zde není cílem ale pouze nástrojem, který má pomoci při vzdělávání. Logo stojí na základech daných takzvanou konstruktivní vzdělávací filozofií a je navrženo k podpoře konstruktivního učení. Konstruktivismus vysvětluje znalosti a dovednosti, jak jsou vytvořeny žáky v jejich vlastních myslích, prostřednictvím vzájemné interakce s jinými lidmi a okolím. Tato zajímavá teorie je spojena především se švýcarským psychologem Jeanem Piagetem, který strávil mnoho času studováním a zdokumentováním učení malých dětí. S Piagetem v Ženevě spolupracoval i Seymour Papert, který později stál u vzniku Loga jakožto poněkud svébytného programovacího jazyka.
Obrázek 31: Pohled na klasické Logo – grafická plocha a příkazový řádek.
První testovací implementace programovacího jazyka Logo se jmenovala „ghost“ a byla vytvořena na slavné MIT společně s firmou BBN (Bolt, Beranek and Newman Inc.) v programovacím jazyce LISP na počítači PDP-1. U zárodku této prvotní implementace, která vznikla už v roce 1967, stál i Seymour Papert, který však jazyk neprogramoval (programátoři, kteří Logo implementovali, se jmenovali Daniel Bobrow a Wallace Feurzeig), ale pracoval jako odborný konzultant. Tato implementace Loga se po nezbytných úpravách postupně rozšířila i mimo MIT, například na univerzitu v Edinburgu. Jméno Logo se objevuje až později s implementací od Wallace Feurzeiga (opět) a Paula Wexelblata, ve které se poprvé objevuje známá želva (turtle), a to dokonce v mechanické podobě a ovládaná radiem (tento robotek se jmenoval Irving).
Obrázek 32: Mechanická želva vytvořená z LEGA a ovládaná programem napsaným v Logu.
Větší rozšíření Loga nastalo až s nástupem osmibitových domácích počítačů. V Evropě jsou známé především značky Sinclair, Atari a Commodore, ale v USA, kde se Logo začalo těšit prakticky masové oblibě, se ještě před těmito značkami rozšířily především osmibitové domácí počítače Apple II (zejména model Apple IIe), které obsahovaly mikroprocesor MOS 6502 (později MOS 6502C) taktovaný na 1MHz. U Apple II bylo možné v grafickém režimu s vysokým rozlišením zobrazovat bitmapy o rozměrech 280×192 pixelů ve čtyřech, popř. v šesti barvách. Takové grafické schopnosti již dostačují k práci želví grafiky, na které je Logo částečně postaveno. Ve stejně době bylo Logo také portováno na počítače Texas Instruments TI 99/4.
Obrázek 33: Schématický květ nakreslený pomocí Loga.
Pravděpodobně nejúspěšnější implementace Loga pro počítače Apple II pochází od firmy LCSI (Logo Computer Systems, Inc.), která v roce 1980 vytvořila Apple Logo. Tato implementace se stala základem i pro verze určené pro novou generaci domácích počítačů – Atari Logo, Commodore Logo (jedna verze Commodore Loga byla postavena nad Terrapin Logem), atd. O tom, jak bylo Apple Logo úspěšné, svědčí i to, že některé moderní komerční implementace Loga ve svých manuálech uvádí převodní tabulku mezi příkazy Apple Loga a jeho moderním protějškem. V kontextu dnešního článku se pochopitelně zaměříme především na Atari Logo, jehož některé unikátní vlastnosti jsou popsány v navazující kapitole.
Obrázek 34: Vzor vytvořený v Logu za pomoci želví grafiky.
11. Unikátní vlastnosti Atari Loga
„Atari Logo is one of the most intelligently-conceived and well-executed pieces of software ever published by ATARI."“
Atari LOGO bylo vyvinuto na základě LCSI Loga, ovšem došlo k několika úpravám, které umožnily do větší míry využít některá specifika osmibitových mikropočítačů Atari. Především byly přidány příkazy pro přehrávání melodií. Konkrétně se jedná o příkaz TOOT, jenž dokáže přehrát notu o zvolené frekvenci, hlasitosti a délce trvání – to je podstatný rozdíl oproti příkazu SOUND v BASICech. Přidány byly taktéž příkazy pro čtení hodnot paddle (tedy analogových ovladačů).
Obrázek 35: Úvodní obrazovka Atari LOGA.
Největší změny se týkají samotné želvy. Kromě jedné želvy (standardní Logo) je totiž možné použít až čtyři želvy (každou s jinou barvou), které lze ovládat buď samostatně nebo je možné stejné příkazy nechat vykonat více želvami. Samotné želvy jsou realizovány sprity, což tvůrcům Atari LOGA umožnilo i další triky – například existují příkazy pro změnu tvaru želvy, příkazy pro zjištění, zda se želva dotkla nějakého nakresleného obrazce (popř. jakou barvu tento obrazec měl) a zjistit lze i kolize dvou želv. Samotný svět, v nichž se želvy pohybují, může být nekonečný, nebo se jeho protilehlé okraje mohou dotýkat tak, jak je to implementováno například ve hře Asteroids.
Obrázek 36: Zobrazení kreslicí plochy a želvy příkazem HOME.
Implicitní zobrazení grafické plochy, po které se želvy pohybují, je realizováno grafickým režimem 7, tj. lze kreslit třemi barvami a používá se rozlišení 160×192 pixelů.
Obrázek 37: Kreslení s použitím dvojice želv.
Obrázek 38: Kreslení pomocí čtyř želv.
Obrázek 39: Všechny čtyři želvy vykonávají stejné příkazy.
12. Interlisp/65 (INTER-LISP/65)
Pro domácí osmibitové mikropočítače Atari vznikl i interpret programovacího jazyka LISP nazvaný Interlisp/65, ovšem označovaný taktéž jako INTER-LISP/65. Jedná se o variantu na (kdysi) slavný jazyk Interlisp, s nímž jsme se již ostatně na stránkách Rootu nedávno setkali v článku Interlisp aneb oživujeme dinosaura. Další odstavce tedy budou uvedeny pouze pro připomenutí.
Obrázek 40: Interpret Interlispu/65.
Jeden z populárních dialektů programovacího jazyka Lisp se jmenoval MacLisp. Ten byl používán ve slavných AI Lab na MITu od konce šedesátých let minulého století až do začátku osmdesátých let, byl po dlouhou dobu považován za neoficiální standard Lispu, tedy za jakousi „referenční implementaci“ (což je dnes zcela běžné – ostatně mnoho moderních programovacích jazyků staví právě na referenční implementaci a nikoli na rigidní specifikaci). MacLisp byl rozšířen na poměrně mnoho platforem, například na PDP-6 a PDP-10, Honeywell 6180, běžel na Multicsu (ten ukázal slepou uličku, kterou se NEvydal pozdější UNIX) atd. Samotný MacLisp se pochopitelně postupně vyvíjel a zajímavé je, že byl použit pro vývoj a implementaci dalších variant programovacích jazyků, mezi jinými i jazyka Scheme. Dále není bez zajímavosti, že první varianta Emacsu založená na Lispu, používala právě MacLisp pro systém Multics (v IT je prostě vše propojeno).
Obrázek 41: Ukázka komunikace s interpretrem Interlispu/65.
Interlisp, jakožto ideový pokračovatel MacLispu, znamenal v době svého vzniku poměrně zásadní změnu v tom, jak byl jazyk a celé jeho interaktivní prostředí navržen. Původní Lispy totiž do značné míry vypadaly tak, jako například dnešní GNU Guile – všechny formy musely být zapsány jako s-výrazy, přičemž se netolerovaly žádné chyby, závorky musely být balancovány atd. Interlisp byl dosti odlišný. Zejména byly rozšířeny možnosti nástrojů dodávaných společně s tímto jazykem – přidán byl například v té době přelomový korektor překlepů, přidány byly balíčky pro práci se soubory, balíček CLISP umožňující zápis algebraických výrazů, programátorský editor pro strukturovaný kód atd. Za většinou nových myšlenek implementovaných v Interlispu stál Warren Teitelman, který napsal svoji disertaci na téma symbiózy mezi člověkem a počítačem. A povšimněte si, že všechny novinky implementované v Interlispu a zmíněné výše se soustředí právě na rozhraní mezi počítačem a uživatelem (resp. programátorem) a nikoli například na nové jazykové konstrukce.
Obrázek 42: Ukázka použití funkce POKE v Interlispu/65.
Příkladem může být korektor překlepů realizovaný balíčkem pojmenovaným DWIM neboli „Do What I Mean“. Pokud se ve formě zapsané uživatelem nacházel neznámý symbol, mohl být balíček DWIM automaticky vyvolán, aby našel správný symbol ze seznamu již definovaných symbolů a nabídl uživateli opravu, korigoval chybu automaticky nebo vypsal chybové hlášení, jak je to dodnes běžné.
Obrázek 43: Pokud se nebudou používat grafické režimy, zůstane Interlispu/65 více operační paměti pro uložení programu a jeho dat.
13. Specifika Interlispu/65
Interlisp/65 byl vydán společností DataSoft v kooperaci s nám již známou firmou Special Software Systems již v roce 1981, což znamená, že vznikl jeden z prvních „alternativních“ jazyků, které vůbec pro osmibitové mikropočítače Atari byly vydány. V mnoha ohledech se jedná o zcela standadní interpret programovacího jazyka LISP, ovšem s tím, že je v některých případech vyžadováno explicitní zavolání správce paměti, a to konkrétně funkcí MEM. Interlisp/65 byl upraven tak, aby do značné míry umožňoval využití grafických a dalších možností počítačů Atari, takže vznikly funkce, které mají obdobu v příkazech BASICu. Jednalo se o funkce pro operaci s pamětí POKE, PEEK a XIO, čtení joysticků (STICK, STRIG), práce se zvukem (SOUND) a práce s grafikou GR, COL, SETCOL, PLOT, DRAW a XIO. Taktéž bylo možné použít I/O operace operačního systému OPEN, CLOSE, PR#, IN# atd. Navíc bylo podporováno ladění funkcemi BREAK a BACKTRACE. Při aritmetických výpočtech se používaly rutiny operačního systému – stejně pomalé, jako v případě Atari BASICu.
Obrázek 44: Manipulace s takzvanými tečka-dvojicemi a se seznamy.
V následující tabulce jsou vypsány všechny funkce, které bylo možné v interpretru Intelispu/65 použít:
| AND | APPEND | APPLY | ASSOC |
| ATOM | BACKTRACE | BREAK | CAR |
| CDR | CLOSE | COL | COND |
| CONS | DEFINE | DEFINEQ | DIR |
| DRAW | EQ | EVAL | EXP |
| GET | GO | GR | IN# |
| INT | LAMBDA | LAST | LENGTH |
| LIST | LOAD | LOG | MACRO |
| MEM | MEMBER | NEW | NIL |
| NLAMBDA | NOTE | NSUBR | OBLIST |
| OPEN | OR | PACK | PAGE |
| PEEK | PLOT | POINT | POKE |
| PR# | PRIN1 | PRIN2 | |
| PROG | PROGN | QUOTE | READ |
| READA | READC | RESET | RETURN |
| RPLACA | RPLACD | SAVE | SET |
| SETCOL | SETQ | SOUND | STICK |
| STRIG | SUB | SUBR | T |
| TAB | TERPRI | UNPACK | XIO |
Obrázek 45: Základní (standardní) funkce pro práci se seznamy.
14. Programovací jazyk Action!
Velmi zajímavým vyšším programovacím jazykem, který byl optimalizován pro použití na osmibitových mikropočítačích, byl jazyk nazvaný Action!. Tento jazyk byl určen pro osmibitové mikropočítače Atari a od ostatních (obecnějších) jazyků se odlišoval zejména tím, že jeho možnosti odrážely schopnosti těchto mikropočítačů (datové typy omezeny na bajt, 16bitový integer se znaménkem a bez znaménka atd.). Syntaxe jazyka Action! je odvozena od Algolu (resp. od Algolské větve jazyků, kam spadá i Pascal), což se týká zejména způsobu zápisu programových smyček a podmínek (IF-FI, DO-OD). Action! podporoval strukturované programování, uživatelé mohli vytvářet lokální proměnné, ovšem ne na zásobníku, jehož velikost i možnosti adresování byly na MOS 6502 omezeny. Zajímavě bylo vyřešeno rozhraní jazyka Action!, protože uživatelé měli k dispozici plnohodnotný textový editor, jednoprůchodový (a tedy rychlý) překladač a monitor, v němž bylo možné provádět i ladění vyvíjené aplikace. Zdrojový text mohl být neustále uložen v operační paměti současně s přeloženou (nativní) aplikací, což bylo umožněno tím, že samotný Action! byl umístěn na přídavném paměťovém modulu (cartridge).
Obrázek 46: Zdrojový kód části programu napsaného v jazyce Action!
V následující tabulce jsou vypsána všechna klíčová slova jazyky Action!:
| AND | FI | OR | UNTIL |
| ARRAY | FOR | POINTER | WHILE |
| BYTE | FUNC | PROC | XOR |
| CARD | IF | RETURN | |
| CHAR | INCLUDE | RSH | |
| DEFINE | INT | SET | |
| DO | LSH | STEP | |
| ELSE | MOD | THEN | |
| ELSEIF | MODULE | TO | |
| EXIT | OD | TYPE |
Obrázek 47: Minimalisticky pojaté prostředí jazyka Action.
15. Datové typy v jazyku Action!
Programovací jazyk Action! podporuje tři základní (primitivní) datové typy pojmenované BYTE, INT a CARD. BYTE představuje osmibitovou hodnotu typu bajt (bez znaménka), INT je šestnáctibitová hodnota se znaménkem a CARD je taktéž šestnáctibitová hodnota, ovšem bez znaménka. Příklad deklarace a popř. i inicializace proměnných těchto typů:
BYTE x,y,z INT num=[0] <- inicializace BYTE x=$8000 <- ulozeni na adresu
Obrázek 48: DOS dodávaný společně s jazykem Action!
Kromě toho lze používat i šestnáctibitové ukazatele, podobně, jako je tomu v jazyku C:
BYTE POINTER ptr CARD POINTER ptr2
Podporována jsou i pole, přičemž inicializaci prvků polí (libovolného typu) lze provést přes řetězcový literál:
BYTE ARRAY pole INT ARRAY x(10) BYTE ARRAY str = "This is a string constant"
Aby toho nebylo málo, je možné deklarovat i vlastní struktury (záznamy), opět podobně jako v jazyku C:
TYPE r=[BYTE b1, b2
INT i1]
Obrázek 49: Jednoduchý program s procedurou INIT, která odpovídá céčkovskému main.
16. Programové konstrukce v jazyku Action!
Programovací jazyk Action! podporuje strukturované programování a má v tomto ohledu zhruba stejné vyjadřovací schopnosti, jako již zmíněný jazyk C či Pascal. Ostatně podívejme se na několik ukázek dostupných programových konstrukcí (včetně odsazení, které je taktéž podporováno).
Implementace podmínky:
IF podmínka THEN
příkazy
příkazy
příkazy
FI
Plné rozvětvení:
IF podmínka THEN
příkazy
příkazy
příkazy
ELSE
příkazy
příkazy
příkazy
FI
Vícenásobné rozvětvení podle většího množství podmínek:
IF podmínka THEN
příkazy
příkazy
příkazy
ELSEIF podmínka THEN
příkazy
příkazy
příkazy
ELSE
příkazy
příkazy
příkazy
FI
Obrázek 50: Přepnutí do příkazového režimu.
Nekonečná smyčka:
DO
příkazy
příkazy
příkazy
OD
Nekonečná smyčka s výskokem uprostřed těla smyčky:
DO
příkazy
příkazy
IF podmínka THEN
EXIT
FI
příkazy
OD
Obrázek 51: Spuštění demonstračního příkladu po jeho překladu.
Programová smyčka typu FOR:
FOR proměnná=start TO end
DO
příkazy
příkazy
příkazy
OD
Alternativní forma se specifikací kroku:
FOR proměnná=start TO end STEP step
DO
příkazy
příkazy
příkazy
OD
Obrázek 52: Složitější program ukazující grafické schopnosti jazyku Action!
Programová smyčka typu WHILE:
WHILE podmínka
DO
příkazy
příkazy
příkazy
OD
Programová smyčka typu REPEAT-UNTIL:
DO
příkazy
příkazy
příkazy
UNTIL podmínka
OD
Obrázek 53: Překlad příkladu do strojového kódu.
Deklarace procedury:
PROC název_procedury(parametry)
příkazy
příkazy
příkazy
RETURN
Deklarace funkce:
type FUNC název_funkce(parametry)
příkazy
příkazy
příkazy
RERUN výraz
Textová makra:
DEFINE size="256" makro DEFINE begin = "DO", end = "OD"
Obrázek 54: Výsledek běhu předchozího příkladu.
17. FIG-Forth
If you're a frequent calculator user, you owe it to yourself to investigate the advantages of RPN. RPN stands for Reverse Polish Notation. Reverse Polish Notation was developed in 1920 by Jan Lukasiewicz as a way to write a mathematical expression without using parentheses and brackets. Hewlett-Packard Co., realizing that Lukasiewicz's method was superior to standard algebraic expressions when using calculators and computers, adapted RPN for its first hand-held scientific calculator, the HP35, in 1972.
Hewlett-Packard Development Company The RPN Method: An Overview and History
Dostáváme se k jazyku Forth (resp. jeho dialektu FIG-Forth), což je jazyk, který byl – alespoň podle mého názoru – pravděpodobně nejlepším a nejvíce vyhovujícím jazykem pro „malé“ osmibitové domácí mikropočítače vůbec – a to, že se více neprosadil, byla možná škoda.
Programovacímu jazyku Forth jsme se již na stránkách Rootu kdysi věnovali v samostatném seriálu. Tento jazyk, který je založený na konceptu dvou zásobníků (jeden je používaný pro operandy a druhý pro uložení návratových adres volajících funkcí), je známý mj. i tím, že jeho implementaci lze v nejjednodušší variantě provést v několika stovkách bajtů paměti, tj. přibližně s 300 až 500 strojovými instrukcemi a navíc se některé dialekty Forthu provozovaly bez použití operačního systému (Forthovské jazyky byly součástí i několika BIOSů). V takto malém počtu instrukcí bude složité uložit jakákoli nebezpečná zadní vrátka. Na druhou stranu je nutné poznamenat, že Forth tvoří svůj velmi zajímavý, ale dosti izolovaný svět, takže v něm pravděpodobně nikdy nevznikne překladač C ani dalšího vyššího programovacího jazyka (typicky se ovšem Forth spojuje s assemblerem, což je ostatně i logičtější).
Obrázek 55: Ze všech dnes popisovaných nástrojů má pouze FIG-Forth vlastní znakovou sadu.
V roce 1976 byla firma FORTH Inc. (jejím zakladatelem byl kdo jiný než Chuck Moore) požádána, aby Forth portovala na mikroprocesor CDP-1802 (mimochodem, tento procesor, určený pro vojenské a kosmické aplikace, měl velmi zajímavý instrukční soubor – viz například stránku Great Microprocessors of the Past and Present, popř. článek RCA 1802: poslední mohykán osmibitové éry mikroprocesorů). Nový produkt byl nazván microFORTH a v dalších letech byl portován na celou skupinu vzájemně odlišných mikroprocesorů, zejména Intel 8080, Motorola 6800, MOS 6502 a Zilog Z80. Systém microFORTH byl s úspěchem použit pro vytváření průmyslových a řídících aplikací, které využívaly právě tyto osmibitové mikroprocesory. Mnohé tyto systémy prý pracují až do dnešní doby (tomu ostatně po zhlédnutí historických sdělovacích a zabezpečovacích zařízení v–některých našich [polo]státních podnicích ochotně věřím – on také nebývá důvod měnit fungující zařízení).
Obrázek 56: Základní operace se zásobníkem operandů.
Všechny výše zmíněné mikroprocesory jsou osmibitové a v průmyslových aplikacích byly osazeny operační pamětí o typické kapacitě 16 kB. Tyto aplikace byly spouštěny většinou z pamětí EPROM nebo PROM, protože disky se používaly pouze v minipočítačích. Ostatní firmy pro tyto mikroprocesory dodávaly buď pouze assembler, nebo jazyk PL/M (raději na něj zapomeňte), ostatní jazyky byly buď příliš náročné na systémové prostředky (C, Pascal), nebo nevhodné pro programování složitějších aplikací (Basic). V této „konkurenci“ je jasné, že se Forth velmi dobře prosazoval, zejména jako náhrada assembleru.
Programovací jazyk Forth byl použit i na osmibitových domácích počítačích. Zde se významně projevila schopnost Forthu generovat krátký kód, který bylo možné zpracovat velmi jednoduchým interpreterem. Ten byl dlouhý pouze několik strojových instrukcí. Jednou z prvních aplikací Forthu v oblasti osmibitových počítačů byly některé systémové rutiny uložené v paměti ROM počítače ZX-81. Jednalo se o operace s hodnotami uloženými v pohyblivé řádové čárce. Pomocí Forthu byl vytvořen velmi krátký kód hojně používající smyčky a iterace. Běh rutin byl díky tomu pomalý, proto byl v dalších počítačích firmy Sinclair Research použit kód psaný přímo v assembleru, který však byl delší.
Obrázek 57: Operace se zásobníkem operandů – SWAP, ROT a OVER.
Osmibitové počítače ještě v době svého největšího rozmachu zažily vznik oblíbeného FIG Forthu (byl odvozen od Forthu-78 a výše zmíněného microFORTHu), jehož autoři si kladli za cíl vytvořit standard mezi různými dialekty Forthu i mezi různými mikroprocesorovými architekturami (například pro Intel 8080). A právě FIG-Forthem se budeme ve stručnosti zabývat v této kapitole. FIG Forth byl portován i na mikroprocesory MOS 6502, takže další přenos na počítače Atari (ale i na BBC Micro, či Commodore C64) byl relativně snadnou záležitostí. FIG Forth byl na Atari vybaven editorem jednotlivých obrazovek (screen), který se ovládal podobně jako Vi či spíše Ed: zadávalo se vždy číslo řádku a operace, která se má provést. Podporována byla všechna slova (v jiných programovacích jazycích funkce) FIG Forthu a díky možnosti přímého přístupu do paměti bylo možné manipulovat s čipy ANTIC, GTIA i POKEY a využít tak i multimediálních možností počítačů Atari. Ostatně prakticky celý manuál FIG Forthu se skládá z popisu jednotlivých slov.
18. Co zbývá?
Mohlo by se zdát, že téma dnešního článku bylo kompletně vyčerpáno, ovšem ve skutečnosti to není v žádném případě pravda, protože i pro „malé“ domácí mikropočítače Atari vznikly i mnohé další programovací jazyky. Jedná se například o poměrně populární interpretry BASICu nazvané BASIC XL a BASIC XE, dále o některé cross assemblery, překladač jazyka Pascal, překladač jazyka C a dokonce jsou k dispozici i některé jazyky používající moderní výdobytky typu JIT překladače. Takovým jazykem je například FastBASIC.
19. Repositář s demonstračními příklady
Na GitHubu nalezneme – pochopitelně vedle zdrojových kódů psaných v moderních programovacích jazycích – mnohdy i vyložené obskurnosti, takže pravděpodobně nebude na škodu zveřejnit několik kódů naprogramovaných v Atari BASICu a taktéž v Turbo-BASICu XL. Vzhledem k odlišnostem mezi ASCII a ATASCII (tedy znakovou sadou používanou v osmibitových mikropočítačích Atari) byly zdrojové kódy převedeny do čitelné podoby, což prakticky znamená, že došlo k převodu znaku pro konec řádku a k dalším nepatrným úpravám (některé emulátory dokážou načíst i takto upravené soubory s využitím zařízení H5):
20. Odkazy na Internetu
- Sedmdesátiny assemblerů: lidsky čitelný strojový kód
https://www.root.cz/clanky/sedmdesatiny-assembleru-lidsky-citelny-strojovy-kod/ - Programovací jazyk BASIC na osmibitových mikropočítačích
https://www.root.cz/clanky/programovaci-jazyk-basic-na-osmibitovych-mikropocitacich/ - Programovací jazyk BASIC na osmibitových mikropočítačích (2)
https://www.root.cz/clanky/programovaci-jazyk-basic-na-osmibitovych-mikropocitacich-2/#k06 - Programovací jazyk BASIC na herní konzoli Atari 2600
https://www.root.cz/clanky/programovaci-jazyk-basic-na-herni-konzoli-atari-2600/ - Stránka magazínu (diskmagu) FLOP
http://flop.atariportal.cz/ - Action (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Action - Assembler (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Assembler - Basic (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Basic - C (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=C - Forth (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Forth - Fortran (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Fortran - Lisp (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Lisp - Logo (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Logo - Pascal (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Pascal - Pilot (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Pilot - PL65 (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=PL65 - Quick (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=Quick - WSFN (AtariWiki.org)
https://atariwiki.org/wiki/Wiki.jsp?page=WSFN - MAC/65 (Wikipedia)
https://en.wikipedia.org/wiki/MAC/65 - Atari Assembler Editor
https://en.wikipedia.org/wiki/Atari_Assembler_Editor#AMAC - cc65
https://cc65.github.io/ - Grafika na osmibitových počítačích firmy Sinclair
http://www.root.cz/clanky/grafika-na-osmibitovych-pocitacich-firmy-sinclair/ - Stránky RetroFestu
http://retrofest.cz/ - RetroHerna
http://retroherna.cz/ - BASIC
http://cs.wikipedia.org/wiki/BASIC - BASIC
http://en.wikipedia.org/wiki/BASIC - Rosetta Code – Category Basic
http://rosettacode.org/wiki/Category:BASIC - Dartmouth College Computation Center: 1964 – The original Dartmouth BASIC manual
http://www.bitsavers.org/pdf/dartmouth/BASIC_Oct64.pdf - The Original BASIC
http://www.truebasic.com/ - BASIC – Beginners All-purpose Symbolic Instruction Code
http://hopl.murdoch.edu.au/showlanguage.prx?exp=176 - Turbo BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Turbo_BASIC - Sinclair BASIC (Wikipedia CZ)
http://cs.wikipedia.org/wiki/Sinclair_BASIC - Action!
https://atari8bitbot.com/action/ - Atari Logo
https://atari8bitbot.com/atari-logo/ - Atari PILOT & Super PILOT
https://atari8bitbot.com/atari-pilot/ - Turbo-BASIC XL
https://atari8bitbot.com/turbo-basic-xl/ - Atari Assembler/Editor
https://atari8bitbot.com/atari-assembler-editor/ - Strings in Atari BASIC
http://www.cyberroach.com/analog/an11/strings.htm - String Arrays in Atari BASIC
http://www.atarimagazines.com/compute/issue11/52_1_STRING_ARRAYS_IN_ATARI_BASIC.php - An Atari BASIC Tutorial
http://www.cyberroach.com/analog/an25/basictutorial.htm - Atari Logo
https://en.wikipedia.org/wiki/Atari_Logo - Computer art and animation : a user's guide to Atari logo
https://archive.org/details/Computer_Art_and_Animation - Going into Action! with Atari XL/XE – Part 1 – Hello World!
https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-1-hello-world/ - Going into Action! with Atari XL/XE – Part 2 – Graphics
https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-2-graphics/ - Going into Action! with Atari XL/XE – Part 3 – More Variables, Memory and Pointers (ugh!)
https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-3-more-variables-memory-and-pointers-ugh/ - Going into Action! with Atari XL/XE – Part 4 – Using VSCode and Action! with syntax highlighting
https://vintageisthenewold.com/going-into-action-with-atari-xl-xe-part-4-using-vscode-and-action-with-syntax-highlighting/ - Atari800 (emulátor)
https://github.com/atari800/atari800 - Atari MAC/65 Tutorial
https://www.youtube.com/watch?v=RyBsGDJBXD0 - MAC/65 Manual
http://www.mixinc.net/atari/mac65.htm - BASIC 10 Liner Contest 2021
https://atariage.com/forums/topic/316645-basic-10-liner-contest-2021/ - Hexadecimální prohlížeče a editory s textovým uživatelským rozhraním
https://www.root.cz/clanky/hexadecimalni-prohlizece-a-editory-s-textovym-uzivatelskym-rozhranim/ - Deep Blue C
https://en.wikipedia.org/wiki/Deep_Blue_C - Deep Blue C Compiler
https://www.atariarchives.org/APX/showinfo.php?cat=20166 - Historie vývoje počítačových her: simulace a strategické hry naprogramované Chrisem Crawfordem
https://www.root.cz/clanky/historie-vyvoje-pocitacovych-her-simulace-a-strategicke-hry-naprogramovane-chrisem-crawfordem/ - Explore BASIC Programming Languages for the Atari 8-Bit Computers (30–60 mins)
http://atariprojects.org/2020/08/29/explore-different-basic-programming-languages-for-the-atari-8-bit-computers-30–60-mins/ - Learn How to Make a Game in BASIC XE (30–60 mins)
http://atariprojects.org/2019/12/21/learn-how-to-make-a-game-in-basic-xe-30–60-mins/ - Atari BASIC XL (manuál)
http://www.atarimania.com/8bit/files/BASIC%20XL%20%C2%A4%20Second%20Edition.pdf - BASIC XE For Atari XL & XE
https://www.atarimagazines.com/compute/issue67/318_1_Reviews_BASIC_XE_For_Atari_XL_XE.php
