Obsah
1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari
2. Stručná historie společnosti Optimized Systems Software (OSS)
9. Doplnění: grafika na mikropočítačích Atari založená na čipech ANTIC a GTIA
10. Porovnání rychlosti některých interpretrů jazyka BASIC pro osmibitová Atari
11. Výsledek prvního benchmarku
12. Výsledek druhého benchmarku
14. Překladače vyšších programovacích jazyků pro osmibitová Atari
17. Cross compilery a cross assemblery
19. Repositář s demonstračními příklady
1. Programovací jazyky používané na platformě osmibitových domácích mikropočítačů Atari
V úvodním článku o vývojových nástrojích dostupných na osmibitových domácích mikropočítačích Atari jsme si popsali některé významné assemblery, zejména pak Atari Assembler Editor a taktéž MAC/65. Poté jsme se zabývali popisem dvou důležitých interpretrů programovacího jazyka BASIC; konkrétně se jednalo o Atari BASIC a taktéž o slavný Turbo BASIC XL.
Obrázek 1: Úvodní obrazovka Turbo-BASICu XL.
Zmínili jsme se i o dalších interpretovaných programovacích jazycích, konkrétně o Interlispu/65 a taktéž o programovacím jazyku Atari LOGO. Nezapomněli jsme ovšem ani na programovací jazyk Forth, konkrétně na jeho dialekt pojmenovaný FIG Forth. A nakonec jsme se zmínili o překladačích, konkrétně o programovacím jazyku Action!, který vznikl pouze pro počítače Atari a přes jeho přednosti se nakonec příliš neprosadil.
Obrázek 2: Pracovní (kreslicí) plocha v Atari LOGu.
Na článek s výše uvedeným stručným obsahem dnes navážeme. V první části se ve stručnosti zmíníme o historii společnosti OSS, druhá část bude věnována popisu dalších důležitých interpretrů programovacího jazyka BASIC, v části třetí porovnáme tyto interpretry s vyžitím značně zjednodušených benchmarků a konečně v části čtvrté se zmíníme o některých překladačích určených pro osmibitová Atari (navážeme tak na část věnovanou jazyku Action!).
Obrázek 3: Interpret Interlispu/65.
Obrázek 4: Prostředí programovacího jazyka Action!
2. Stručná historie společnosti Optimized Systems Software (OSS)
Zastavme se ještě na chvíli u assembleru MAC/65 a programovacího jazyka Action!, které byly zmíněny v úvodní kapitole. Za vznikem těchto vývojářských nástrojů stála jediná firma OSS neboli plným jménem Optimized Systems Software. Tato společnost se orientovala převážně na vývoj nástrojů užitečných pro vývojáře, a to jak pro amatéry (v kladném smyslu tohoto slova), tak i pro profesionální společnosti. Tato firma vznikla v roce 1981, takže by letos oslavila (pokud by ovšem existovala – ovšem jen málo firem přežilo hektickou dobu IT mezi lety 1980 až přibližně 1995) kulaté výročí svého vzniku.
Obrázek 5: Úvodní obrazovka assembleru MAC/65 verze 1.02.
Historie společnosti OSS se začala psát vlastně již se vznikem Atari BASICu. Víme, že Atari BASIC vlastně vznikl až poté, co se ukázalo, že společnost Micro-Soft nedokáže svůj Atari Microsoft BASIC „nacpat“ do požadované kapacity ROM – osmi kilobajtů (ovšem Atari Microsoft BASIC byl nakonec vydán, a to dokonce ve dvou verzích, jak uvidíme dále). Za vznikem OSS stáli Bill Wilkinson, Mike Peters, Paul Laughton a Kathleen O'Brien, přičemž třetí jmenovaný vydal Atari BASIC a jeho žena Kathleen pracovala mj. i na FP rutinách operačního systému Atari. Původní Atari BASIC a taktéž první verze DOSu byla odkoupena od společnosti Shepardson Microsystems, která ukončila svoji existenci právě v roce 1981 a kde původně zakladatelé OSS pracovali. V dalších letech se OSS věnovala jak rozšiřování možností původních produktů (řada DOS, řada BASICů), tak i dalším projektům, mj. i jazyku Action!
Obrázek 6: Debugger DDT vestavěný do assembleru MAC/65.
Příkladem produktu OSS je OS/A+, tedy dosový systém založený na systému menu. Později vznikl DOS XL, který podporoval diskety s dvojnásobnou hustotou a kromě menu se ovládal i příkazovou řádkou nazývanou CP neboli command processor. OSS vyvinula i takzvanou supercartridge s kapacitou 16kB.
Příklad menu z DOSu XL:
C - Copy Files P - Protect Files D - Duplicate Disk Q - Quit to DOS XL E - Erase Files R - Rename File F - Files on Disk S - Save Binary G - Go to Address T - To Cartridge I - Initialize Disk U - Unprotect Files L - Load Binary X - Xtended Command
Na příkazovém řádku byly podporovány interní příkazy, mezi něž patří například D1: (přepnutí disků), DIR, END, ERA atd. A většinou byly k dispozici i příkazy externí: COPY, DUPDSK, VERIFY atd.
Obrázek 7: DOS dodávaný společně s jazykem Action! Konkrétně se jedná o DOS XL.
Z portfolia společnosti OSS stojí za zmínku především:
- Interpretry BASICu rozšiřující a zrychlující původní Atari BASIC: BASIC A+, BASIC XL a BASIC XE
- Assemblery a debuggery: EASMD (Edit/ASseMble/Debug) vydaný již v roce 1981, MAC/65, BUG/65
- Další programovací jazyky či jejich překladače: Action!, C/65, Tiny C interpretr subsetu jazyka C, Personal Pascal pro Atari ST 1987
Obrázek 8: Jednoduchý program s procedurou INIT, která odpovídá céčkovskému main, zde ovšem používající syntaxi jazyka Action!
3. Debugger BUG/65
V úvodní kapitole jsme se zmínili mj. o tom, že společnost OSS vyvinula mj. i programátorský nástroj nazvaný BUG/65 (což je mimochodem zajímavé jméno, podobně jako kdyby výrobce automobilů pojmenoval svůj model Šrot). Jedná se o poměrně pokročilý debugger, který ovšem obsahuje i možnosti monitoru a současně i jednoduchého assembleru s interaktivním zápisem instrukcí a dalších jazykových konstrukcí. Původně měl být BUG/65 dodáván společně s assemblerem MAC/65, ovšem nakonec byl dodáván samostatně, a to jak ve verzi pro cartridge, tak i v disketové verzi (společně s DOSem od stejné společnosti; existuje ovšem i kombinace MAC/65+BUG/65).
Obrázek 9: Jeden z prodávaných „bundlů“ – DOS XL + MAC/65 + BUG/65.
Obrázek 10: Úvodní obrazovka debuggeru BUG/65 (barvy jsou na tomto screenshotu pravé).
BUG/65 podporuje přibližně čtyřicet operací. Patří mezi ně operace, které očekáváme od monitorů: práce s operační pamětí, tj. zobrazení obsahu vybraného bloku, zápis do paměti, zápis řetězce do paměti, porovnání dvou bloků paměti či výplň vybraného bloku. Blok paměti je možné zapsat na disketu, připojit k existujícímu souboru či ho pochopitelně nahrát zpět z diskety do paměti. Podporována je i nízkoúrovňová práce s disketovými sektory. BUG/65 taktéž obsahuje disassembler, dokáže nastavovat breakpointy, specifikovat počet opakování průchodu breakpointem, trasovat (krokovat) programy po jednotlivých instrukcích, provádět krokování s přeskokem subrutin (JSR); zobrazit je pochopitelně i obsah pracovních registrů mikroprocesoru MOS 6502 i jeho příznakových bitů NV-BDIZC. Při všech těchto operacích lze samotný BUG/65 ochránit před přepisem. Třetí částí je assembler, který je řádkově orientovaný – každý řádek se zkontroluje a přeloží do strojového kódu.
Obrázek 11: Porovnání dvou bloků operační paměti.
BUG/65 obsahuje vlastní ovladač bufferu příkazového řádku, takže není podporován celoobrazovkový editor dostupný v OS. Lze vkládat více příkazů na řádek, poslední řádek je možné opakovat stiskem ENTER, u zadávání adres atd. jsou podporovány základní aritmetické operátory a vkládání hodnot lze realizovat jak v desítkové, tak i v hexadecimální soustavě. Nejzajímavější příkazy jsou:
A zápis ASCII řetězce do paměti na zadanou adresu C porovnání dvou bloků paměti (start, end, start) D zobrazení obsahu bloku paměti F výplň bloku paměti G skok na adresu L vyhledání sekvence hexa čísel v paměti T trace - krokování/trasování TS krokováni s přeskokem subrutin Y disassembler (start, end) V zobrazení obsahu registrů Z assembler
Obrázek 12: Disassembler podporovaný nástrojem BUG/65.
Zápis více příkazů na řádku:
D 1000 1010 D 2000 2010
Vzhledem k tomu, že druhý parametr u příkazu D je volitelný, musí se zkrácený zápis provést takto:
D 1000, D 2000 2010
Obrázek 13: Zobrazení obsahu pracovních registrů.
4. BASIC A+
V roce 1983 byl společností OSS vydán dialekt BASICu pojmenovaný BASIC A+. Tento dialekt obsahoval opravy a vylepšení původního Atari BASICu a navíc byl tento interpret rychlejší, než původní BASIC (viz též výsledky benchmarků uvedených v jedenácté a dvanácté kapitole). Zajímavé je, že BASIC A+ nebyl dodáván na cartridge, ale na disketě, a to společně se systémem OS/A+ a EASMD (Editor/Assembler). Celková cena za tyto tři programy byla 80 dolarů, takže je patrné že se jednalo o jiný segment trhu, než tomu bylo v případě profesionálnějších nástrojů BUG/65 a MAC/65. Samotný interpret zabral dalších 15 kB RAM. Byl (jak již víme) rychlejší než původní Atari BASIC, obsahoval základní podporu pro PMG (sprity) a taktéž základní podporu pro ladění programů.
Obrázek 14: Úvodní obrazovka BASIC A+.
Díky přímé podpoře OS/A+ došlo k úpravám (resp. k vylepšením) následujících příkazů jazyka BASIC, přičemž některé příkazy (konkrétně poslední čtyři) byly nově přidány:
CLOSE ENTER GET INPUT LIST LOAD NOTE OPEN POINT PRINT PUT SAVE PROTECT (XIO 35) UNPROTECT (XIO 36) RENAME (XIO 32) ERASE (XIO 33)
Obrázek 15: Samotný interpret zabral dalších 15 kB RAM a nepracoval s odklopenou ROM, což je zde jasně patrné.
5. BASIC XL
O další rok později, tedy v roce 1984, vydala společnost OSS další 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ů.
Obrázek 16: Úvodní obrazovka BASICu XL.
První vylepšení spočívá v možnosti příkazem FAST provést přepočet cílů skoků, což má za následek citelné urychlení běhu programů. Dále byla přidána podpora pro dvourozměrné pole řetězců:
DIM A$(10,100)
K přístupu k první a druhé dimenzi se používá středník, protože čárka je již v Atari BASICu použita pro přístup k podřetězcům:
A$(1;)="TEST"
Obrázek 17: Verze na cartridge nabízí stejnou volnou kapacitu RAM, jako původní Atari BASIC.
Přidán byl i příkaz MOVE pro rychlé přesuny bloku paměti. K dispozici je i několik příkazů pro práci se sprity/PMG:
PMGRAPHICS - povolení PMG PMMOVE - přesun hráče BUMP - detekce kolize MISSILE - pozicování střely na y ové souřadnici PMMOVE - posun hráče -1,0,+1 - podle joysticku PMWIDTH - šířka hráče PMCOLOR - barva hráče PMADR/PMCLR - práce s paměti alokované pro PMG
Užitečné jsou i příkazy VSTICK a HSTICK, které podle náklonu joysticku vrací hodnoty –1, 0 nebo 1, takže není nutné provádět ruční dekódování polohy z čísel 0–15.
Chování interpretru lze ovlivnit příkazem SET, podporováno je trasování (výpis čísel řádků) i automatické číslování řádků. Zapomenout nesmíme ani na chybové zprávy, v nichž se kromě číselných kódů vypisuje i podrobnější informace o typu chyby. A nakonec jsou podporovány další příkazy určené pro strukturované programování:
IF/ELSE/ENDIF WHILE/ENDWHILE
Obrázek 18: Automatické odsazení bloků kódu a použití malých písmen v příkazech.
6. BASIC XE
V roce 1985 společnost OSS vydala svoji poslední verzi interpretru programovacího jazyka BASIC pro osmibitová Atari. Tato varianta se jmenovala 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).
Obrázek 19: Úvodní opbrazovka BASICu XE.
Vzhledem k roku vzniku je patrné, že BASIC XE byl přímou konkurencí k již popsanému Turbo BASICu XL, který byl navíc nabízen ve formě freeware (a nakonec i open source v původním významu tohoto sousloví). Turbo BASIC sice v některých ohledech nedosahoval možností BASICu XL (PMG apod.), ovšem byl rychlejší, podporoval všechny strukturované jazykové konstrukce a samozřejmě v neposlední řadě rozhodovala cena. Ve výsledku byl BASIC XE ztrátovým projektem.
Obrázek 20: Práce s PMG – černá čárka uprostřed obrazovky je hráč, který je zobrazen nezávisle na pozadí.
7. Atari Microsoft BASIC
Dalším interpretrem programovacího jazyka BASIC, s nímž se v dnešním článku ve stručnosti seznámíme, je Atari Microsoft BASIC. Na historii jeho vzniku jsme již upozornili v předchozím článku – původně totiž měly být domácí osmibitové mikropočítače Atari skutečně dodávány s Microsoft BASICem uloženým v ROM, ovšem nakonec nebylo možné tento interpret umístit do požadovaných osmi kilobajtů ROM, takže jako vhodnější alternativa vznikl Atari BASIC. Nicméně společnost Micro-soft skutečně Atari Microsoft BASIC vydala, a to již v roce 1981. 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.
Obrázek 21: Atari Microsoft BASIC ponechává programátorům k dispozici pouze 21022 bajtů paměti, což je oproti jiným intepretrům velmi malá hodnota.
Poměrně velký rozdíl spočívá v tom, že se pro výpočty používají odlišné datové typy. Microsoft BASIC totiž podporuje šestnáctibitová celá čísla se znaménkem, hodnoty typu single (s plovoucí řádovou čárkou) uložené ve čtyřech bajtech, hodnoty typu double (taktéž s plovoucí řádovou čárkou) uložené v osmi bajtech a pochopitelně taktéž řetězce. Zcela jsou tedy vynechány šestibajtové hodnoty s plovoucí řádovou čárkou a s nechvalně známými pomalými subrutinami pro výpočty. A navíc – díky použití datových typů single a double je do poměrně velké míry zachována kompatibilita s ostatními interpretry Microsoft BASICu na některých dalších platformách, především na tehdy vznikající platformě IBM PC (a to tehdy s velkou pravděpodobností nikdo ani netušil, jak tato platforma pomůže společnosti Micro-Soft, později Microsoft, v dalším rozvoji).
Typ proměnné bylo možné určit postfixovým znakem:
- # – typ double
- % – typ int
- $ – typ string
Alternativně bylo možné příkazy DEFSNG, DEFDBL, DEFINT či DEFSTR určit typ pro všechny proměnné začínající určitým znakem.
Dalším rozdílem je podpora polí s větším počtem dimenzí. Připomeňme si, že Atari BASIC i Turbo BASIC podporovaly jednorozměrné či dvourozměrné pole s číselnými hodnotami (tedy vlastně vektory a matice) a řetězce považované za jednorozměrná pole znaků. Naproti tomu v Microsoft BASICu mohly mít pole libovolný typ a teoretický počet dimenzí byl omezen na 255 (takže vlastně neomezen, když vezmeme v úvahu pouze cca 21kB volné RAM). Ovšem s touto vlastností souvisí i odlišný přístup k podřetězcům, neboť „atarácký“ zápis A$(od, do) není možné použít – znamená něco jiného, totiž přístup do dvourozměrného znakového pole. Namísto toho jsou dostupné funkce LEFT$, RIGHT$ a MID$, které v Microsoftích interpretrech přežily pravděpodobně až do současnosti.
Obrázek 22: Základní funkce pro práci s řetězci.
V Microsoft BASICu nalezneme i příkaz OPTION, který mění chování interpretru, popř. práci s pamětí. Dostupné jsou tyto varianty tohoto příkazu:
- OPTION BASE 0–1: změna indexování polí od nuly nebo jedničky
- OPTION PLM0,1,2: rezervace paměti pro PMG (sprity)
- OPTION CHR0,1,2: rezervace paměti pro znakovou sadu
- OPTION RESERVE : rezervace bloku paměti o specifikované délce
V Microsoft BASICu se objevily i příkazy INKEY$ (čtení klávesy), TIME$, PRINT USING (formátovaný výstup), PRINT AT (výstup na zadané místo), LINE INPUT atd.
Nakonec nesmíme zapomenout na možnost definice jednoduchých jednořádkových funkcí:
DEF AVG(X,Y)=(X+Y)/2
8. Atari Microsoft BASIC II
O rok později po vydání původního Atari Microsoft BASICu (tedy v roce 1982) byla vydána jeho druhá verze s několika opravami a taktéž s několika novými příkazy. Jedná se zejména o příkaz AUTO zajišťující automatické generování čísel řádků a dále o velmi užitečný příkaz MOVE určený pro přesuny paměťových bloků (o dva až tři řády rychlejší, než v samotném BASICu). Příkazem COMMON bylo možné specifikovat ty proměnné, které „přežijí“ samotný program a bude je možné využít v dalším kódu – to teoreticky umožňuje vytvářet moduly, minimálně při použití disketové jednotky.
Obrázek 23: Úvodní obrazovka Microsoft BASICu II.
Další příkazy do jisté míry umožňují programování založené na zachytávání a zpracování událostí. Příkazem AFTER se deklaruje později spouštěný kód; jeho případné vedlejší efekty odstraňuje příkaz CLEAR STACK (navíc existuje i příkaz PRINT STACK). A nejzajímavější je příkaz WAIT … AND, který čeká na změnu provedenou v operační paměti (například rutinou volanou z přerušení) a reaguje na ni.
Obrázek 24: Definice nové funkce na řádku 30, použití této funkce v následujících řádcích.
Teoreticky by měl být interpret Atari Microsoft BASICu II rychlejší, než jeho původní varianta, ovšem z benchmarků vychází spíše opačné výsledky (viz navazující kapitoly).
9. Doplnění: grafika na mikropočítačích Atari založená na čipech ANTIC a GTIA
V předchozích kapitolách jsme se několikrát setkali s termínem sprity a PMG, takže si je nyní ve stručnosti vysvětlíme. Na osmibitových počítačích Atari se grafika skládala ze dvou částí: pozadí (hrací pole, playfield) a pohyblivých rastrových obrázků (spritů, PMG). Pro nastavení grafického režimu pozadí (playfield) byl určen obvod ANTIC (Alpha-Numeric Television Interface Circuit), který umožnil pro každý vykreslovaný řádek (scanline) programově nastavit jeden ze čtrnácti grafických režimů, které se lišily svým rozlišením, počtem současně zobrazitelných barev a velikostí alokované paměti.
S obvodem ANTIC úzce spolupracoval číslicový obvod GTIA (Graphics Television Interface Adapter nebo také George's Television Interface Adapter), který zaváděl podporu pro další tři šestnáctibarevné grafické režimy s horizontálním rozlišením 80 pixelů na řádek, a především umožňoval vykreslování spritů. Současně bylo možné vykreslit čtyři sprity s rozlišením maximálně 8×256 pixelů a další čtyři sprity s rozlišením 2×256 pixelů, které bylo možno spojit do jednoho většího (pátého) spritu s rozlišením 8×256 pixelů.
Sprity široké 8 pixelů se v literatuře nazývají hráči (players), úzké dvoupixelové sprity střely (missiles).
Sprity byly jednobarevné, více barev bylo možno dosáhnout logickými operacemi nad překrývajícími se sprity (počítače Commodore C64 naproti tomu nabízely i sprity v režimu multicolor). Každý sprite mohl pomocí jedné instrukce měnit svoji horizontální velikost i horizontální pozici, přičemž polohy spritů byly navzájem nezávislé.
Vertikální pozice spritů se měnila přesunem bitmapy spritu v operační paměti. Bylo také možné definovat priority vykreslování spritů vůči sobě navzájem i vůči pozadí. Na následujícím obrázku je zobrazen způsob vykreslování grafiky s použitím obvodů ANTIC a GTIA:
Obrázek 25: Základní role čipů ANTIC a GTIA v osmibitových domácích mikropočítačích Atari.
10. Porovnání rychlosti některých interpretrů jazyka BASIC pro osmibitová Atari
Rychlost jednotlivých interpretrů programovacího jazyka BASIC zjistíme s využitím dvojice jednoduchých benchmarků. U obou benchmarků se bude měřit čas běhu části programu, přičemž pro měření použijeme časovač dostupný na adresách 18, 19 a 20. Tento časovač lze programově vynulovat:
10 REM VYMAZANI CASOVACE 11 POKE 18,0 12 POKE 19,0 13 POKE 20,0
Na konci programu zjistíme stav časovače a převedeme ho na sekundy podělením půlsnímkovou frekvencí (50 či 60 Hz podle použité televizní normy):
40 REM PRECTENI CASOVACE 41 REM (PLATNE PRO PAL) 42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50) 50 PRINT "FINISHED IN ";T;" SECONDS"
Obrázek 26: Část prvního benchmarku v prostředí Atari BASICu.
První benchmark je založen na měření doby setřídění padesáti čísel algoritmem bubble sort:
1 REM ***************************** 2 REM BUBBLE SORT 3 REM IMPLEMENTACE PRO ATARI BASIC 4 REM UPRAVENO DO PODOBY BENCHMARKU 5 REM ***************************** 6 REM 7 REM 8 REM 9 REM 10 REM VYMAZANI CASOVACE 11 POKE 18,0 12 POKE 19,0 13 POKE 20,0 20 REM VLASTNI BENCHMARK 21 MAX=50 22 DIM A(MAX) 23 FOR I=0 TO MAX 24 A(I)=INT(100*RND(0)) 25 NEXT I 26 GOSUB 100:REM TISK OBSAHU POLE 27 FOR I=MAX-1 TO 0 STEP -1 28 PRINT "."; 29 FOR J=0 TO I 30 IF A(J)<A(J+1) THEN X=A(J):A(J)=A(J+1):A(J+1)=X 31 NEXT J 32 NEXT I 33 PRINT "" 34 PRINT "SORTED:" 35 GOSUB 100:REM TISK OBSAHU POLE 40 REM PRECTENI CASOVACE 41 REM (PLATNE PRO PAL) 42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50) 50 PRINT "FINISHED IN ";T;" SECONDS" 99 END 100 REM TISK OBSAHU POLE 101 FOR I=0 TO MAX 102 PRINT I,A(I) 103 NEXT I 104 RETURN
Program je nutné převést z čitelné (textové) podoby do ATASCII, například takto:
tr "\n" "\233" < bench_s.bas > B.BAS
Načtení do interpretru:
ENTER "H:B.BAS"
V případě Microsoft BASICu není příkaz ENTER dostupný, takže se použije:
LOAD "H:B.BAS"
Obrázek 27: Část prvního benchmarku v prostředí Atari BASICu.
Obrázek 28: Výsledek běhu prvního benchmarku.
Obrázek 29: Část prvního benchmarku v prostředí Turbo BASICu XL.
Druhý benchmark je jednodušší a testuje rychlost smyček a přístupu do paměti. Program po svém spuštění zaplní obrazovou paměť náhodnými hodnotami a simuluje tak „sněžení“ analogového televizoru bez antény:
1 REM ***************************** 2 REM VYPLNENI OBRAZOVKY NAHODNYM VZOREM 3 REM IMPLEMENTACE PRO ATARI BASIC 4 REM UPRAVENO DO PODOBY BENCHMARKU 5 REM ***************************** 6 REM 7 REM 8 REM 9 REM 10 REM VYMAZANI CASOVACE 11 POKE 18,0 12 POKE 19,0 13 POKE 20,0 20 REM VLASTNI BENCHMARK 21 GRAPHICS 8 22 START=PEEK(88)+256*PEEK(89) 23 FINAL=START+320*160/8 30 FOR I=START TO FINAL 35 REM 17BITOVY POLY CITAC = RND 40 POKE I,PEEK(53770) 50 NEXT I 60 REM PRECTENI CASOVACE 70 REM (PLATNE PRO PAL) 80 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50) 90 PRINT "FINISHED IN ";T;" SECONDS" 99 END
Obrázek 30: Druhý benchmark v prostředí Atari BASICu.
Obrázek 31: Výsledek běhu druhého benchmarku.
11. Výsledek prvního benchmarku
Podívejme se nyní na výsledky prvního benchmarku, který byl prakticky beze změn v programovém kódu spuštěn ve všech osmi klasických interpretrech programovacího jazyka BASIC dostupných na osmibitových Atari. Provedli jsme pouze jedinou změnu, a to na pátém řádku, kdy byl doplněn příkaz FAST, jenž umožňuje přepočítat čísla řádků do podoby umožňující rychlejší (přímé) skoky. A tato změna skutečně způsobila nepatrné vylepšení výsledků (pro BASIC XE se již v případě příkazu FAST vyžaduje 128kB RAM, takže by byl použitelný jen na Atari 130 XE):
| Interpret | Čas |
|---|---|
| Atari BASIC | 33.46 |
| BASIC A+ | 30.10 |
| Turbo BASIC XL | 15.86 |
| BASIC XL | 18.90 |
| BASIC XL (FAST) | 16.32 |
| BASIC XE | 20.9 |
| Microsoft Atari BASIC | 30.10 |
| Microsoft Atari BASIC II | 31.36 |
Obrázek 32: Výsledek prvního benchmarku se zvýrazněním nejlepšího a nejhoršího výsledku.
Z výsledků je patrné, že nejrychlejší je Turbo BASIC XL, jehož název tedy v žádném případě nelže. Nejpomalejší je původní Atari BASIC, ovšem Microsoft Atari BASIC mu svou „pomalostí“ zdárně sekunduje.
1 REM ******************************** 2 REM BUBBLE SORT PRO POLE TYPU SINGLE 3 REM IMPLEMENTACE PRO MICROSOFT BASIC 4 REM UPRAVENO DO PODOBY BENCHMARKU 5 REM ******************************** 6 REM 7 REM 8 REM 9 REM 10 REM VYMAZANI CASOVACE 11 POKE 18,0 12 POKE 19,0 13 POKE 20,0 20 REM VLASTNI BENCHMARK 21 MAX%=50 22 DIM A(MAX%) 23 FOR I%=0 TO MAX% 24 A(I%)=INT(100*RND(0)) 25 NEXT I% 26 GOSUB 100:REM TISK OBSAHU POLE 27 FOR I%=MAX%-1 TO 0 STEP -1 28 PRINT "."; 29 FOR J%=0 TO I% 30 IF A(J%)<A(J%+1) THEN X=A(J%):A(J%)=A(J%+1):A(J%+1)=X 31 NEXT J% 32 NEXT I% 33 PRINT "" 34 PRINT "SORTED:" 35 GOSUB 100:REM TISK OBSAHU POLE 40 REM PRECTENI CASOVACE 41 REM (PLATNE PRO PAL) 42 T=((PEEK(18)*65536+PEEK(19)*256+PEEK(20))/50) 50 PRINT "FINISHED IN ";T;" SECONDS" 99 END 100 REM TISK OBSAHU POLE 101 FOR I%=0 TO MAX% 102 PRINT I%,A(I%) 103 NEXT I% 104 RETURN
12. Výsledek druhého benchmarku
Nyní si zobrazme výsledky druhého benchmarku, tedy vyplnění obrazové paměti náhodnými hodnotami:
| Interpret | Čas | |
|---|---|---|
| Atari BASIC | 73.28 | |
| BASIC A+ | 45.88 | |
| Turbo BASIC XL | 17.14 | |
| BASIC XL | 34.38 | |
| BASIC XL (FAST) | 27.06 | |
| BASIC XE | 63.14 | |
| Microsoft Atari BASIC | 65.18 | |
| Microsoft Atari BASIC II | 65.22 |
Obrázek 33: Výsledek druhého benchmarku se zvýrazněním nejlepšího a nejhoršího výsledku.
Vítěz je v tomto případě opět jasný – je jím Turbo BASIC XL. Druhý nejrychlejší čas dosažený BASICem XL s příkazem FAST je mnohem horší (o celých deset sekund). Nejpomalejší je opět původní Atari BASIC.
13. Fast BASIC
Nejnovějším BASICem navrženým a implementovaným pro domácí osmibitové mikropočítače Atari je Fast BASIC. Jedná se projekt, který je v mnoha ohledech odlišný od klasických BASICů – namísto překladu zdrojového kódu do sekvence tokenů se používá překladač do bajtkódu. To je koncept, který známe například z Pythonu, 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. Výsledek je v každém případě rychlejší, než interpretace tokenizovaného kódu.
Obrázek 34: Vývojové prostředí Fast BASICu.
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í, 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 je jedním z důvodů, proč byla čísla řádků vůbec zavedena).
Obrázek 35: Vývojové prostředí Fast BASICu.
14. Překladače vyšších programovacích jazyků pro osmibitová Atari
Mezi nejpoužívanější jazyky populární v dobách osmibitových domácích mikropočítačů skutečně patřily zejména assemblery a interpretry BASICu, tj. jazyky zmíněné v předchozích kapitolách i v předchozím článku. 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 36: Logo překladačů Aztec C.
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). V navazujícím textu se zaměříme především na Pascal, konkrétně na Kyan Pascal.
Obrázek 37: Jeden z konkurenčních překladačů k Aztec C byl Lattice C (ovšem až v pozdější době).
15. Programovací jazyk Pascal
O programovacím jazyku Pascal jsme se již zmínili v předchozí kapitole, takže se zde seznámíme s některými technickými zajímavostmi. Překladače Pascalu se typicky používaly na počítačích vybavených buď disketovou jednotkou nebo alespoň paměťovým modulem (s Pascalem) a kazetovým magnetofonem. Disketová jednotka umožňovala relativně rychlé přepínání mezi editorem, překladačem (a linkerem) a spuštěním vytvářené aplikace, tj. vlastně ten styl práce, který se v mnoha případech používá dodnes. Alternativní způsob založený na použití paměťového modulu s ROM či EPROM obsahující editor, překladač i linker, kladlo větší omezení na velikost vytvářené aplikace, protože v jedné chvíli byl (alespoň většinou) v operační paměti uložen jak zdrojový text, tak i přeložená binární aplikace.
Obrázek 38: Manuál k Pascalu určeného pro mikropočítače Commodore C64.
Obrázek 39: Paměťový modul s Pascalem pro československé osmibitové mikropočítače PMD-85.
16. Kyan Pascal
Pro osmibitová Atari a taktéž pro počítače Apple II vzniklo několik překladačů Pascalu. Dnes se zmíníme o Kyan Pascalu. Jednalo se o jazyk vydaný až v roce 1987; jde tedy o jeden z nejnovějších nástrojů zmíněných v dnešním článku. Kyan Pascal byl dodáván na disketě a jeho jednotlivé části se musely postupně zavádět a spouštět právě z diskety. K dispozici byl editor, překladač, nástroj pro použití tiskárny atd. atd. Samotný překlad byl prováděn v jednom průchodu (což Pascal ve většině případů umožňuje), takže samotná fáze překladu byla relativně rychlá. Podporována byla většina standardních jazykových konstrukcí. Ke Kyan Pascalu vznikly i různé knihovny, například pro grafiku, práci se želvou, fonty atd.
Obrázek 40: Úvodní obrazovka Kyan Pascalu.
Na disketě byla dodávána i kontextová nápověda:
Obrázek 41: Nápověda.
Zajímavý byl editor použitý v Kyan Pascalu. Ten totiž pracoval jinak, než standardní celoobrazovkový editor (byl blíže chování dnešních editorů) – pokud byl kurzor na konci zapsaného příkazu, znamenal stisk šipky doprava přechod na nový řádek a naopak stisk šipky doleva na začátku řádku převedl kurzor na konec předchozího řádku.
Obrázek 42: Editor Kyan Pascalu.
17. Cross compilery a cross assemblery
V článku o vývojových prostředích a nástrojích určených pro osmibitové domácí mikropočítače Atari pochopitelně nemůžeme zapomenout ani na cross compilery a cross assemblery (viz poznámka o českém překladu tohoto názvu). Tyto typy nástrojů jsou velmi často používané i dnes, zejména v oblasti mikrořadičů, digitálních signálových procesorů nebo mobilních telefonů (viz například Scratchbox). Ovšem tato technologie se používala již na začátku osmibitové éry. Například vývoj her pro herní konzoli Atari 2600 (Atari Video Computer System neboli Atari VCS) byl prováděn na minipočítači. Ovšem i později některé firmy vyvíjely profesionální software pro Atari i další osmibitové mikropočítače na výkonnějších strojích, kde se prováděl i překlad.
Dobrým a možná i typickým příkladem jsou cross překladače programovacího jazyka C. Tvorbou těchto cross překladačů se zabývala například společnost Manx Software Systems, jejíž překladače céčka (Aztec C) určené pro IBM PC s DOSem i pro osobní mikropočítače Macintosh dokázaly provádět cross překlad na osmibitové mikropočítače Commodore C64 a Apple II. Na chvíli se u Aztec C zastavme, i když přímo nesouvisí s osmibitovými Atari.
Aztec C totiž byl ve své době velmi úspěšný překladač, jenž existoval jak ve verzi pro osmibitové mikroprocesory (MOS 6502, Zilog Z-80), tak i pro mikroprocesory 16bitové a 32bitové. Tento překladač byl velmi úspěšný právě na Amize, kde byl používán, společně s Lattice C, prakticky až do faktického zániku této platformy. Ovšem na IBM PC jeho sláva netrvala dlouho, především z toho důvodu, že firma Microsoft považovala segment překladačů za poměrně důležitý a snažila se vytlačit jakoukoli konkurenci z trhu (i když ve skutečnosti v té době ještě neměla vlastní céčkový překladač. Společnosti Manx Software Systems se postupně zmenšoval počet platforem, na něž bylo možné překladač prodávat a přechod na podporu vestavěných systémů již přišel dosti pozdě. A právě pro cross překlad se Aztec C může používat dodnes (běží v DOSu, takže dnes vlastně taktéž v emulovaném prostředí).
Podobným stylem byl řešen i Microsoft C původně vytvořený společností, která stála za slavným Lattice C. Ostatně Lattice C byl s velkou pravděpodobností vůbec prvním překladačem céčka pro IBM PC (pochází z roku 1982). Ten byl později převeden i na Amigu, dále se rozšířil i na minipočítače a mainframy společnosti IBM. Firma Microsoft překladač Lattice C nabízela pod svým názvem MSC (Microsoft C) a teprve verze MSC 4.0 byla skutečně vytvořena přímo programátory z Microsoftu. Lattice C byl používán i při portaci aplikací z operačního systému CP/M na DOS (dnes je však možné pouze odhadnout, kolik kódu bylo skutečně napsáno v céčku a kolik kódu vzniklo transformací assembleru).
18. Obsah závěrečného článku
Ve třetím a současně i posledním článku z tohoto miniseriálku se zaměříme především na popis výše zmíněných cross překladačů a cross assemblerů určených pro osmibitové domácí mikropočítače Atari. Zmíníme se například o projektu ATasm, který je používán dodnes, podobně jako cross překladač programovacího jazyka C.
19. Repositář s demonstračními příklady
Zdrojové kódy dnes i minule ukázaných příkladů byly zveřejněny v repositáři https://github.com/tisnik/8bit-fame/. 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):
Příklady pro původní a originální Atari BASIC
Příklady pro Turbo BASIC XL
Příklady pro Microsoft BASIC
| # | Jméno souboru | Stručný popis souboru | Cesta |
|---|---|---|---|
| 1 | strings.bas | zpracování řetězců v Microsoft BASICu | https://github.com/tisnik/8bit-fame/blob/master/Microsoft%20BASIC/strings.bas |
| 2 | def_func.bas | definice funkcí v Microsoft BASICu | https://github.com/tisnik/8bit-fame/blob/master/Microsoft%20BASIC/def_func.bas |
| 3 | sort.bas | setřídění pole bubble sortem | https://github.com/tisnik/8bit-fame/blob/master/Microsoft%20BASIC/sort.bas |
| 4 | sort_int.bas | setřídění pole bubble sortem, použití celočíselných indexů | https://github.com/tisnik/8bit-fame/blob/master/Microsoft%20BASIC/sort_int.bas |
| 5 | sort_int_int.bas | setřídění pole celých čísel bubble sortem, použití celočíselných indexů | https://github.com/tisnik/8bit-fame/blob/master/Microsoft%20BASIC/sort_int_int.bas |
Benchmarky
| # | Jméno souboru | Stručný popis souboru | Cesta |
|---|---|---|---|
| 1 | bubble_sort.bas | první benchmark: bubble sort | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/bubble_sort.bas |
| 2 | bubble_sort.csv | výsledek benchmarku v CSV formátu | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/bubble_sort.csv |
| 3 | bubble_sort.png | výsledek benchmarku ve formě sloupcového grafu | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/bubble_sort.png |
| 4 | snowcrash.bas | druhý benchmark: vykreslení šumu na obrazovku | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/snowcrash.bas |
| 5 | snowcrash.csv | výsledek benchmarku v CSV formátu | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/snowcrash.csv |
| 6 | snowcrash.png | výsledek benchmarku ve formě sloupcového grafu | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/snowcrash.png |
| 7 | plot_benchmark_results.py | skript pro vykreslení grafů s výsledkem benchmarků | https://github.com/tisnik/8bit-fame/blob/master/benchmarks/plot_benchmark_results.py |
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 - BUG/65 (Reference manual)
https://atariwiki.org/wiki/attach/Bug65/BUG-65%20Version%202.0%20manual-final%20with%20errorpage.pdf - Cross compiler
https://en.wikipedia.org/wiki/Cross_compiler - Křížový překladač
https://cs.wikipedia.org/wiki/K%C5%99%C3%AD%C5%BEov%C3%BD_p%C5%99eklada%C4%8D - ATasm
https://atari.miribilist.com/atasm/ - ATasm v1.09 („Global Pandemic Release“)
https://atari.miribilist.com/atasm/atasm.pdf - DOS XL
https://en.wikipedia.org/wiki/DOS_XL - Aztec C online Museum
https://www.clipshop.ca/Aztec/index.htm - Aztec C Compilers
http://aztecmuseum.ca/compilers.htm - Scratchbox
http://scratchbox.org/ - History of PC based C-compilers
https://web.archive.org/web/20071215083657/http://www.itee.uq.edu.au/~csmweb/decompilation/hist-c-pc.html - PAL/NTSC Upgrade
https://www.myatari.com/nirdary.html - How can you measure time using BASIC on Atari XL computers?
https://retrocomputing.stackexchange.com/questions/269/how-can-you-measure-time-using-basic-on-atari-xl-computers - Atari Microsoft Basic manual
http://www.atarimania.com/8bit/files/Atari_Microsoft_Basic.pdf
ČLÁNKY DO MAILU